diff --git a/include/engine/phantom_node.hpp b/include/engine/phantom_node.hpp
index 88823da6e..cc47ade08 100644
--- a/include/engine/phantom_node.hpp
+++ b/include/engine/phantom_node.hpp
@@ -25,21 +25,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef PHANTOM_NODES_H
-#define PHANTOM_NODES_H
+#ifndef OSRM_ENGINE_PHANTOM_NODES_H
+#define OSRM_ENGINE_PHANTOM_NODES_H
 
 #include "extractor/travel_mode.hpp"
-#include "util/typedefs.hpp"
 
+#include "util/typedefs.hpp"
 #include "util/bearing.hpp"
 #include "util/coordinate.hpp"
 
 #include <boost/assert.hpp>
 
-#include <iostream>
-#include <utility>
-#include <vector>
-
 namespace osrm
 {
 namespace engine
@@ -200,30 +196,6 @@ struct PhantomNodes
     PhantomNode target_phantom;
 };
 
-inline std::ostream &operator<<(std::ostream &out, const PhantomNodes &pn)
-{
-    out << "source_coord: " << pn.source_phantom.location << "\n";
-    out << "target_coord: " << pn.target_phantom.location << std::endl;
-    return out;
-}
-
-inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
-{
-    out << "node1: " << pn.forward_segment_id.id << ", "
-        << "node2: " << pn.reverse_segment_id.id << ", "
-        << "fwd-w: " << pn.forward_weight << ", "
-        << "rev-w: " << pn.reverse_weight << ", "
-        << "fwd-o: " << pn.forward_weight_offset << ", "
-        << "rev-o: " << pn.reverse_weight_offset << ", "
-        << "fwd-d: " << pn.forward_duration << ", "
-        << "rev-d: " << pn.reverse_duration << ", "
-        << "fwd-do: " << pn.forward_duration_offset << ", "
-        << "rev-do: " << pn.reverse_duration_offset << ", "
-        << "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
-        << "pos: " << pn.fwd_segment_position << ", "
-        << "loc: " << pn.location;
-    return out;
-}
 }
 }
 
diff --git a/include/extractor/intersection/intersection_view.hpp b/include/extractor/intersection/intersection_view.hpp
index f73495c62..1ff3c4cdc 100644
--- a/include/extractor/intersection/intersection_view.hpp
+++ b/include/extractor/intersection/intersection_view.hpp
@@ -75,10 +75,6 @@ struct IntersectionViewData : IntersectionShapeData
     bool CompareByAngle(const IntersectionViewData &other) const;
 };
 
-// small helper function to print the content of a connected road
-std::string toString(const IntersectionShapeData &shape);
-std::string toString(const IntersectionViewData &view);
-
 // Intersections are sorted roads: [0] being the UTurn road, then from sharp right to sharp left.
 // common operations shared amongst all intersection types
 template <typename Self> struct EnableShapeOps
diff --git a/include/extractor/turn_lane_types.hpp b/include/extractor/turn_lane_types.hpp
index a3d19bd9f..bb0cc4275 100644
--- a/include/extractor/turn_lane_types.hpp
+++ b/include/extractor/turn_lane_types.hpp
@@ -1,20 +1,18 @@
 #ifndef OSRM_GUIDANCE_TURN_LANE_TYPES_HPP_
 #define OSRM_GUIDANCE_TURN_LANE_TYPES_HPP_
 
+#include "util/concurrent_id_map.hpp"
+#include "util/integer_range.hpp"
+#include "util/typedefs.hpp"
+
+#include <boost/functional/hash.hpp>
+
 #include <bitset>
 #include <cstddef>
 #include <cstdint>
 #include <numeric> //partial_sum
-#include <string>
-#include <unordered_map>
 #include <vector>
 
-#include <boost/functional/hash.hpp>
-
-#include "util/concurrent_id_map.hpp"
-#include "util/json_container.hpp"
-#include "util/typedefs.hpp"
-
 namespace osrm
 {
 namespace extractor
@@ -22,23 +20,23 @@ namespace extractor
 
 namespace TurnLaneType
 {
-namespace detail
+const constexpr std::size_t NUM_TYPES = 11;
+
+inline auto laneTypeToName(const std::size_t type_id)
 {
-const constexpr std::size_t num_supported_lane_types = 11;
-
-const constexpr char *translations[detail::num_supported_lane_types] = {"none",
-                                                                        "straight",
-                                                                        "sharp left",
-                                                                        "left",
-                                                                        "slight left",
-                                                                        "slight right",
-                                                                        "right",
-                                                                        "sharp right",
-                                                                        "uturn",
-                                                                        "merge to left",
-                                                                        "merge to right"};
-
-} // namespace detail
+    const static char *name[NUM_TYPES] = {"none",
+                                          "straight",
+                                          "sharp left",
+                                          "left",
+                                          "slight left",
+                                          "slight right",
+                                          "right",
+                                          "sharp right",
+                                          "uturn",
+                                          "merge to left",
+                                          "merge to right"};
+    return name[type_id];
+}
 
 typedef std::uint16_t Mask;
 const constexpr Mask empty = 0u;
@@ -54,30 +52,6 @@ const constexpr Mask uturn = 1u << 8u;
 const constexpr Mask merge_to_left = 1u << 9u;
 const constexpr Mask merge_to_right = 1u << 10u;
 
-inline std::string toString(const Mask lane_type)
-{
-    if (lane_type == 0)
-        return "none";
-
-    std::bitset<8 * sizeof(Mask)> mask(lane_type);
-    std::string result = "";
-    for (std::size_t lane_id_nr = 0; lane_id_nr < detail::num_supported_lane_types; ++lane_id_nr)
-        if (mask[lane_id_nr])
-            result += (result.empty() ? detail::translations[lane_id_nr]
-                                      : (std::string(";") + detail::translations[lane_id_nr]));
-
-    return result;
-}
-
-inline util::json::Array toJsonArray(const Mask lane_type)
-{
-    util::json::Array result;
-    std::bitset<8 * sizeof(Mask)> mask(lane_type);
-    for (std::size_t lane_id_nr = 0; lane_id_nr < detail::num_supported_lane_types; ++lane_id_nr)
-        if (mask[lane_id_nr])
-            result.values.push_back(detail::translations[lane_id_nr]);
-    return result;
-}
 } // TurnLaneType
 
 typedef std::vector<TurnLaneType::Mask> TurnLaneDescription;
@@ -93,8 +67,9 @@ struct TurnLaneDescription_hash
     }
 };
 
-typedef util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID, TurnLaneDescription_hash>
-    LaneDescriptionMap;
+using LaneDescriptionMap = util::ConcurrentIDMap<TurnLaneDescription,
+                                                 LaneDescriptionID,
+                                                 TurnLaneDescription_hash>;
 
 using TurnLanesIndexedArray =
     std::tuple<std::vector<std::uint32_t>, std::vector<TurnLaneType::Mask>>;
diff --git a/include/util/coordinate.hpp b/include/util/coordinate.hpp
index a708383ba..6f2096703 100644
--- a/include/util/coordinate.hpp
+++ b/include/util/coordinate.hpp
@@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef COORDINATE_HPP_
-#define COORDINATE_HPP_
+#ifndef OSRM_UTIL_COORDINATE_HPP_
+#define OSRM_UTIL_COORDINATE_HPP_
 
 #include "util/alias.hpp"
 
@@ -216,7 +216,6 @@ struct Coordinate
     bool IsValid() const;
     friend bool operator==(const Coordinate lhs, const Coordinate rhs);
     friend bool operator!=(const Coordinate lhs, const Coordinate rhs);
-    friend std::ostream &operator<<(std::ostream &out, const Coordinate coordinate);
 };
 
 /**
@@ -257,13 +256,10 @@ struct FloatCoordinate
     bool IsValid() const;
     friend bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs);
     friend bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs);
-    friend std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate);
 };
 
 bool operator==(const Coordinate lhs, const Coordinate rhs);
 bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs);
-std::ostream &operator<<(std::ostream &out, const Coordinate coordinate);
-std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate);
 
 inline Coordinate::Coordinate(const FloatCoordinate &other)
     : Coordinate(toFixed(other.lon), toFixed(other.lat))
diff --git a/include/util/debug.hpp b/include/util/debug.hpp
index 541683e7a..c318f0d64 100644
--- a/include/util/debug.hpp
+++ b/include/util/debug.hpp
@@ -1,5 +1,5 @@
-#ifndef OSRM_ENGINE_GUIDANCE_DEBUG_HPP_
-#define OSRM_ENGINE_GUIDANCE_DEBUG_HPP_
+#ifndef OSRM_UTIL_DEBUG_HPP_
+#define OSRM_UTIL_DEBUG_HPP_
 
 #include "extractor/node_data_container.hpp"
 #include "extractor/query_node.hpp"
@@ -19,100 +19,174 @@ namespace osrm
 {
 namespace util
 {
+inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
+{
+    out << std::setprecision(12) << "{" << toFloating(coordinate.lon) << ", "
+        << toFloating(coordinate.lon) << "}";
+    return out;
+}
+}
 
+namespace engine
+{
 namespace guidance
 {
-
-inline void print(const engine::guidance::RouteStep &step)
+inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 {
-    std::cout << static_cast<int>(step.maneuver.instruction.type) << " "
-              << static_cast<int>(step.maneuver.instruction.direction_modifier) << "  "
-              << static_cast<int>(step.maneuver.waypoint_type) << " " << step.maneuver.location
-              << " "
-              << " Duration: " << step.duration << " Distance: " << step.distance
-              << " Geometry: " << step.geometry_begin << " " << step.geometry_end
-              << " Exit: " << step.maneuver.exit << " Mode: " << (int)step.mode
-              << "\n\tIntersections: " << step.intersections.size() << " [";
+    out << "RouteStep {" << static_cast<int>(step.maneuver.instruction.type) << " "
+        << static_cast<int>(step.maneuver.instruction.direction_modifier) << "  "
+        << static_cast<int>(step.maneuver.waypoint_type) << " " << step.maneuver.location << " "
+        << " Duration: " << step.duration << " Distance: " << step.distance
+        << " Geometry: " << step.geometry_begin << " " << step.geometry_end
+        << " Exit: " << step.maneuver.exit << " Mode: " << (int)step.mode
+        << "\n\tIntersections: " << step.intersections.size() << " [";
 
     for (const auto &intersection : step.intersections)
     {
-        std::cout << "(Lanes: " << static_cast<int>(intersection.lanes.lanes_in_turn) << " "
-                  << static_cast<int>(intersection.lanes.first_lane_from_the_right) << " ["
-                  << intersection.in << "," << intersection.out << "]"
-                  << " bearings:";
+        out << "(Lanes: " << static_cast<int>(intersection.lanes.lanes_in_turn) << " "
+            << static_cast<int>(intersection.lanes.first_lane_from_the_right) << " ["
+            << intersection.in << "," << intersection.out << "]"
+            << " bearings:";
         for (auto bearing : intersection.bearings)
-            std::cout << " " << bearing;
-        std::cout << ", entry: ";
+            out << " " << bearing;
+        out << ", entry: ";
         for (auto entry : intersection.entry)
-            std::cout << " " << (entry ? "true" : "false");
-        std::cout << ")";
+            out << " " << (entry ? "true" : "false");
+        out << ")";
     }
-    std::cout << "] name[" << step.name_id << "]: " << step.name << " Ref: " << step.ref
-              << " Pronunciation: " << step.pronunciation << "Destination: " << step.destinations
-              << "Exits: " << step.exits;
+    out << "] name[" << step.name_id << "]: " << step.name << " Ref: " << step.ref
+        << " Pronunciation: " << step.pronunciation << "Destination: " << step.destinations
+        << "Exits: " << step.exits << "}";
+
+    return out;
+}
+}
 }
 
-inline void print(const std::vector<engine::guidance::RouteStep> &steps)
+namespace guidance
 {
-    std::cout << "Path\n";
+inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
+{
+    out << "ConnectedRoad {" << road.eid << " allows entry: " << road.entry_allowed
+        << " angle: " << road.angle << " bearing: " << road.bearing
+        << " instruction: " << static_cast<std::int32_t>(road.instruction.type) << " "
+        << static_cast<std::int32_t>(road.instruction.direction_modifier) << " "
+        << static_cast<std::int32_t>(road.lane_data_id) << "}";
+    return out;
+}
+}
+
+namespace extractor
+{
+namespace intersection
+{
+inline std::ostream &operator<<(std::ostream &out, const IntersectionShapeData &shape)
+{
+    out << "IntersectionShapeData { " << shape.eid << " bearing: " << shape.bearing << "}";
+    return out;
+}
+
+inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &view)
+{
+    out << "IntersectionViewData {" << view.eid << " allows entry: " << view.entry_allowed
+        << " angle: " << view.angle << " bearing: " << view.bearing << "}";
+    return out;
+}
+}
+
+
+namespace TurnLaneType
+{
+inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
+{
+    if (lane_type == 0)
+    {
+        out << "none";
+        return out;
+    }
+
+    bool first = true;
+    std::bitset<8 * sizeof(Mask)> mask(lane_type);
+    for (auto index : util::irange<std::size_t>(0, NUM_TYPES))
+    {
+        if (!first)
+        {
+            out << ";";
+        }
+
+        if (mask[index])
+        {
+            out << laneTypeToName(index);
+            first = false;
+        }
+    }
+
+    return out;
+}
+}
+}
+}
+
+namespace std
+{
+inline std::ostream &operator<<(std::ostream &out,
+                                const std::vector<osrm::engine::guidance::RouteStep> &steps)
+{
+    out << "{";
     int segment = 0;
     for (const auto &step : steps)
     {
-        std::cout << "\t[" << segment++ << "]: ";
-        print(step);
-        std::cout << std::endl;
+        if (segment > 0)
+            out << ", ";
+        out << step;
+        segment++;
     }
+    out << "}";
+
+    return out;
+}
 }
 
-inline void print(const osrm::guidance::Intersection &intersection)
+namespace osrm
 {
-    std::cout << "  Intersection:\n";
-    for (const auto &road : intersection)
-        std::cout << "\t" << toString(road) << "\n";
-    std::cout << std::flush;
-}
-
-inline void print(const NodeBasedDynamicGraph &node_based_graph,
-                  const osrm::guidance::Intersection &intersection)
+namespace guidance
 {
-    std::cout << "  Intersection:\n";
+inline std::ostream &operator<<(std::ostream &out, const Intersection &intersection)
+{
+    out << "Intersection {";
+    int segment = 0;
     for (const auto &road : intersection)
     {
-        std::cout << "\t" << toString(road) << "\n";
-        std::cout << "\t\t"
-                  << node_based_graph.GetEdgeData(road.eid).flags.road_classification.ToString()
-                  << "\n";
+        if (segment > 0)
+            out << ", ";
+        out << road;
+        segment++;
     }
-    std::cout << std::flush;
+    out << "}";
+    return out;
 }
 
-inline void print(const osrm::guidance::lanes::LaneDataVector &turn_lane_data)
+namespace lanes
 {
-    std::cout << " Tags:\n";
+inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_lane_data)
+{
+    out << " LaneDataVector {";
+    int segment = 0;
     for (auto entry : turn_lane_data)
-        std::cout << "\t" << entry.tag << "(" << extractor::TurnLaneType::toString(entry.tag)
-                  << ") from: " << static_cast<int>(entry.from)
-                  << " to: " << static_cast<int>(entry.to) << "\n";
-    std::cout << std::flush;
+    {
+        if (segment > 0)
+            out << ", ";
+        out << entry.tag << "(" << entry.tag << ") from: " << static_cast<int>(entry.from)
+            << " to: " << static_cast<int>(entry.to);
+        segment++;
+    }
+    out << "}";
+
+    return out;
+}
 }
 
-inline void printTurnAssignmentData(const NodeID at,
-                                    const osrm::guidance::lanes::LaneDataVector &turn_lane_data,
-                                    const osrm::guidance::Intersection &intersection,
-                                    const std::vector<extractor::QueryNode> &node_info_list)
-{
-    std::cout << "[Turn Assignment Progress]\nLocation:";
-    auto coordinate = node_info_list[at];
-    std::cout << std::setprecision(12) << toFloating(coordinate.lat) << " "
-              << toFloating(coordinate.lon) << "\n";
-
-    print(intersection);
-    // flushes as well
-    print(turn_lane_data);
 }
-
-} // namespace guidance
-} // namespace util
-} // namespace osrm
+}
 
 #endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/
diff --git a/src/engine/api/json_factory.cpp b/src/engine/api/json_factory.cpp
index f9184cbec..88d59f724 100644
--- a/src/engine/api/json_factory.cpp
+++ b/src/engine/api/json_factory.cpp
@@ -46,6 +46,20 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
     return intersection.lanes.lanes_in_turn > 0;
 }
 
+inline util::json::Array toJSON(const extractor::TurnLaneType::Mask lane_type)
+{
+    util::json::Array result;
+    std::bitset<8 * sizeof(extractor::TurnLaneType::Mask)> mask(lane_type);
+    for (auto index : util::irange<std::size_t>(0, extractor::TurnLaneType::NUM_TYPES))
+    {
+        if (mask[index])
+        {
+            result.values.push_back(extractor::TurnLaneType::laneTypeToName(index));
+        }
+    }
+    return result;
+}
+
 util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection &intersection)
 {
     BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1);
@@ -56,7 +70,7 @@ util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection
     {
         --lane_id;
         util::json::Object lane;
-        lane.values["indications"] = extractor::TurnLaneType::toJsonArray(lane_desc);
+        lane.values["indications"] = toJSON(lane_desc);
         if (lane_id >= intersection.lanes.first_lane_from_the_right &&
             lane_id <
                 intersection.lanes.first_lane_from_the_right + intersection.lanes.lanes_in_turn)
diff --git a/src/guidance/roundabout_handler.cpp b/src/guidance/roundabout_handler.cpp
index fe08a761b..f8dd04fc0 100644
--- a/src/guidance/roundabout_handler.cpp
+++ b/src/guidance/roundabout_handler.cpp
@@ -6,6 +6,7 @@
 #include "util/coordinate_calculation.hpp"
 #include "util/guidance/name_announcements.hpp"
 #include "util/log.hpp"
+#include "util/to_osm_link.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -177,7 +178,7 @@ bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
                 // but is at least not random.
                 if (src_coordinate == next_coordinate)
                 {
-                    util::Log(logDEBUG) << "Zero length segment at " << next_coordinate
+                    util::Log(logDEBUG) << "Zero length segment at " << toOSMLink(next_coordinate)
                                         << " could cause invalid roundabout exit bearings";
                     BOOST_ASSERT(std::abs(result.back()) <= 0.1);
                 }
@@ -210,7 +211,9 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
     std::unordered_set<unsigned> connected_names;
 
     const auto getNextOnRoundabout = [this, &roundabout_name_ids, &connected_names](
-        const NodeID node, const bool roundabout, const bool circular) {
+                                         const NodeID node,
+                                         const bool roundabout,
+                                         const bool circular) {
         BOOST_ASSERT(roundabout != circular);
         EdgeID continue_edge = SPECIAL_EDGEID;
         for (const auto edge_id : node_based_graph.GetAdjacentEdgeRange(node))
diff --git a/src/guidance/turn_classification.cpp b/src/guidance/turn_classification.cpp
index 9dd23e4c3..1fee7e04f 100644
--- a/src/guidance/turn_classification.cpp
+++ b/src/guidance/turn_classification.cpp
@@ -1,5 +1,7 @@
 #include "guidance/turn_classification.hpp"
 
+#include "util/to_osm_link.hpp"
+
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
@@ -56,8 +58,10 @@ classifyIntersection(Intersection intersection, const osrm::util::Coordinate &lo
             if (road.entry_allowed)
             {
                 if (!entry_class.activate(number))
+                {
                     util::Log(logWARNING) << "Road " << number << " was not activated at "
-                                          << location;
+                                          << util::toOSMLink(location);
+                }
             }
 
             auto discrete_bearing_class =
@@ -74,8 +78,10 @@ classifyIntersection(Intersection intersection, const osrm::util::Coordinate &lo
             if (road.entry_allowed)
             {
                 if (!entry_class.activate(number))
+                {
                     util::Log(logWARNING) << "Road " << number << " was not activated at "
-                                          << location;
+                                          << util::toOSMLink(location);
+                }
             }
             bearing_class.add(std::round(road.bearing));
             ++number;
diff --git a/src/guidance/turn_lane_data.cpp b/src/guidance/turn_lane_data.cpp
index 4ea893fab..4527ac62b 100644
--- a/src/guidance/turn_lane_data.cpp
+++ b/src/guidance/turn_lane_data.cpp
@@ -76,7 +76,7 @@ LaneDataVector laneDataFromDescription(TurnLaneDescription turn_lane_description
             return (test_mask & full_mask) == test_mask;
         };
 
-        for (std::size_t shift = 0; shift < TurnLaneType::detail::num_supported_lane_types; ++shift)
+        for (const auto shift : util::irange<std::size_t>(0, TurnLaneType::NUM_TYPES))
         {
             TurnLaneType::Mask mask = 1 << shift;
             if (isSet(mask))
diff --git a/src/util/coordinate.cpp b/src/util/coordinate.cpp
index ac4c2d6e3..cc5a5b3f8 100644
--- a/src/util/coordinate.cpp
+++ b/src/util/coordinate.cpp
@@ -43,16 +43,5 @@ bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs)
 bool operator!=(const Coordinate lhs, const Coordinate rhs) { return !(lhs == rhs); }
 bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs) { return !(lhs == rhs); }
 
-std::ostream &operator<<(std::ostream &out, const Coordinate coordinate)
-{
-    out << std::setprecision(12) << "(lon:" << toFloating(coordinate.lon)
-        << ", lat:" << toFloating(coordinate.lat) << ")";
-    return out;
-}
-std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate)
-{
-    out << std::setprecision(12) << "(lon:" << coordinate.lon << ", lat:" << coordinate.lat << ")";
-    return out;
-}
 }
 }
diff --git a/unit_tests/engine/douglas_peucker.cpp b/unit_tests/engine/douglas_peucker.cpp
index 232892156..53ed1d3d9 100644
--- a/unit_tests/engine/douglas_peucker.cpp
+++ b/unit_tests/engine/douglas_peucker.cpp
@@ -1,5 +1,6 @@
 #include "engine/douglas_peucker.hpp"
 #include "util/coordinate_calculation.hpp"
+#include "util/debug.hpp"
 
 #include <boost/test/test_case_template.hpp>
 #include <boost/test/unit_test.hpp>
diff --git a/unit_tests/partitioner/bisection_graph.cpp b/unit_tests/partitioner/bisection_graph.cpp
index 92d7c13f4..7c1cf8ece 100644
--- a/unit_tests/partitioner/bisection_graph.cpp
+++ b/unit_tests/partitioner/bisection_graph.cpp
@@ -1,6 +1,8 @@
 #include "partitioner/bisection_graph.hpp"
 #include "partitioner/graph_generator.hpp"
 
+#include "util/debug.hpp"
+
 #include <algorithm>
 #include <vector>
 
diff --git a/unit_tests/partitioner/bisection_graph_view.cpp b/unit_tests/partitioner/bisection_graph_view.cpp
index a78cd7508..94ca9b17e 100644
--- a/unit_tests/partitioner/bisection_graph_view.cpp
+++ b/unit_tests/partitioner/bisection_graph_view.cpp
@@ -2,6 +2,8 @@
 #include "partitioner/graph_generator.hpp"
 #include "partitioner/recursive_bisection_state.hpp"
 
+#include "util/debug.hpp"
+
 #include <algorithm>
 #include <climits>
 #include <vector>
diff --git a/unit_tests/server/parameters_parser.cpp b/unit_tests/server/parameters_parser.cpp
index f7358500e..448b624e4 100644
--- a/unit_tests/server/parameters_parser.cpp
+++ b/unit_tests/server/parameters_parser.cpp
@@ -10,6 +10,8 @@
 #include "engine/api/tile_parameters.hpp"
 #include "engine/api/trip_parameters.hpp"
 
+#include "util/debug.hpp"
+
 #include <boost/optional/optional_io.hpp>
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
diff --git a/unit_tests/util/coordinate_calculation.cpp b/unit_tests/util/coordinate_calculation.cpp
index add13d2a1..c45479ed1 100644
--- a/unit_tests/util/coordinate_calculation.cpp
+++ b/unit_tests/util/coordinate_calculation.cpp
@@ -4,6 +4,7 @@
 #include "util/bearing.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/web_mercator.hpp"
+#include "util/debug.hpp"
 
 #include <osrm/coordinate.hpp>