tests: rename variables '.*svgAnalyzer' to '.*svg_analyzer'

Almost no other variables use camel case.

diff --git a/tests/svgpp_context.cpp b/tests/svgpp_context.cpp
index 11f457e4f31525a9ba1fd30df46cef1499917e18..2b19d03c4dce92340422abaccc2226ebdc00ac3c 100644 (file)
--- a/tests/svgpp_context.cpp
+++ b/tests/svgpp_context.cpp
@@ -12,54 +12,54 @@ static std::string to_color_string(SvgppContext::color_t color) {
                      (color >> 0) & 0xff);
 }
 
-SvgppContext::SvgppContext(ISVGAnalyzer *svgAnalyzer)
-    : m_svgAnalyzer(svgAnalyzer){};
+SvgppContext::SvgppContext(ISVGAnalyzer *svg_analyzer)
+    : m_svg_analyzer(svg_analyzer){};
 
 void SvgppContext::on_enter_element(svgpp::tag::element::svg) {
-  m_svgAnalyzer->on_enter_element_svg();
+  m_svg_analyzer->on_enter_element_svg();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::g) {
-  m_svgAnalyzer->on_enter_element_g();
+  m_svg_analyzer->on_enter_element_g();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::circle) {
-  m_svgAnalyzer->on_enter_element_circle();
+  m_svg_analyzer->on_enter_element_circle();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::ellipse) {
-  m_svgAnalyzer->on_enter_element_ellipse();
+  m_svg_analyzer->on_enter_element_ellipse();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::line) {
-  m_svgAnalyzer->on_enter_element_line();
+  m_svg_analyzer->on_enter_element_line();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::path) {
-  m_svgAnalyzer->on_enter_element_path();
+  m_svg_analyzer->on_enter_element_path();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::polygon) {
-  m_svgAnalyzer->on_enter_element_polygon();
+  m_svg_analyzer->on_enter_element_polygon();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::polyline) {
-  m_svgAnalyzer->on_enter_element_polyline();
+  m_svg_analyzer->on_enter_element_polyline();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::rect) {
-  m_svgAnalyzer->on_enter_element_rect();
+  m_svg_analyzer->on_enter_element_rect();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::text) {
-  m_svgAnalyzer->on_enter_element_text();
+  m_svg_analyzer->on_enter_element_text();
 }
 
 void SvgppContext::on_enter_element(svgpp::tag::element::title) {
-  m_svgAnalyzer->on_enter_element_title();
+  m_svg_analyzer->on_enter_element_title();
 }
 
-void SvgppContext::on_exit_element() { m_svgAnalyzer->on_exit_element(); }
+void SvgppContext::on_exit_element() { m_svg_analyzer->on_exit_element(); }
 
 void SvgppContext::path_move_to(double x, double y,
                                 svgpp::tag::coordinate::absolute c) {
@@ -67,7 +67,7 @@ void SvgppContext::path_move_to(double x, double y,
     throw std::runtime_error{
         "'path_move_to' using relative coordinates is not yet implemented"};
   }
-  m_svgAnalyzer->path_move_to(x, y);
+  m_svg_analyzer->path_move_to(x, y);
 }
 
 void SvgppContext::path_line_to(double, double,
@@ -83,7 +83,7 @@ void SvgppContext::path_cubic_bezier_to(double x1, double y1, double x2,
         "'path_cubic_bezier_to' using relative coordinates "
         "is not yet implemented"};
   }
-  m_svgAnalyzer->path_cubic_bezier_to(x1, y1, x2, y2, x, y);
+  m_svg_analyzer->path_cubic_bezier_to(x1, y1, x2, y2, x, y);
 }
 
 void SvgppContext::path_quadratic_bezier_to(double, double, double, double,
@@ -101,18 +101,18 @@ void SvgppContext::path_close_subpath() {
   throw std::runtime_error{"'path_close_subpath' is not yet implemented"};
 }
 
-void SvgppContext::path_exit() { m_svgAnalyzer->path_exit(); }
+void SvgppContext::path_exit() { m_svg_analyzer->path_exit(); }
 
 void SvgppContext::set(svgpp::tag::attribute::cy, const double v) {
-  m_svgAnalyzer->set_cy(v);
+  m_svg_analyzer->set_cy(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::cx, const double v) {
-  m_svgAnalyzer->set_cx(v);
+  m_svg_analyzer->set_cx(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::fill, svgpp::tag::value::none) {
-  m_svgAnalyzer->set_fill("none");
+  m_svg_analyzer->set_fill("none");
 }
 
 void SvgppContext::set(svgpp::tag::attribute::fill,
@@ -123,11 +123,11 @@ void SvgppContext::set(svgpp::tag::attribute::fill,
 
 void SvgppContext::set(svgpp::tag::attribute::fill, color_t color,
                        svgpp::tag::skip_icc_color) {
-  m_svgAnalyzer->set_fill(to_color_string(color));
+  m_svg_analyzer->set_fill(to_color_string(color));
 }
 
 void SvgppContext::set(svgpp::tag::attribute::stroke, svgpp::tag::value::none) {
-  m_svgAnalyzer->set_stroke("none");
+  m_svg_analyzer->set_stroke("none");
 }
 
 void SvgppContext::set(svgpp::tag::attribute::stroke,
@@ -139,7 +139,7 @@ void SvgppContext::set(svgpp::tag::attribute::stroke,
 void SvgppContext::set(svgpp::tag::attribute::stroke,
                        SvgppContext::color_t color,
                        svgpp::tag::skip_icc_color) {
-  m_svgAnalyzer->set_stroke(to_color_string(color));
+  m_svg_analyzer->set_stroke(to_color_string(color));
 }
 
 void SvgppContext::transform_matrix(const boost::array<double, 6> &matrix) {
@@ -149,7 +149,7 @@ void SvgppContext::transform_matrix(const boost::array<double, 6> &matrix) {
   double d = matrix.at(3);
   double e = matrix.at(4);
   double f = matrix.at(5);
-  m_svgAnalyzer->set_transform(a, b, c, d, e, f);
+  m_svg_analyzer->set_transform(a, b, c, d, e, f);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::r, const double) {
@@ -157,11 +157,11 @@ void SvgppContext::set(svgpp::tag::attribute::r, const double) {
 }
 
 void SvgppContext::set(svgpp::tag::attribute::rx, const double v) {
-  m_svgAnalyzer->set_rx(v);
+  m_svg_analyzer->set_rx(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::ry, const double v) {
-  m_svgAnalyzer->set_ry(v);
+  m_svg_analyzer->set_ry(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::x1, const double) {
@@ -181,7 +181,7 @@ void SvgppContext::set(svgpp::tag::attribute::y2, const double) {
 }
 
 void SvgppContext::set(svgpp::tag::attribute::x, const double v) {
-  m_svgAnalyzer->set_x(v);
+  m_svg_analyzer->set_x(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::x, const NumbersRange &range) {
@@ -189,11 +189,11 @@ void SvgppContext::set(svgpp::tag::attribute::x, const NumbersRange &range) {
     throw std::runtime_error{
         "Multiple value list for the 'x' attribute is not yet implemented"};
   }
-  m_svgAnalyzer->set_x(*range.begin());
+  m_svg_analyzer->set_x(*range.begin());
 }
 
 void SvgppContext::set(svgpp::tag::attribute::y, const double v) {
-  m_svgAnalyzer->set_y(v);
+  m_svg_analyzer->set_y(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::y, const NumbersRange &range) {
@@ -201,34 +201,34 @@ void SvgppContext::set(svgpp::tag::attribute::y, const NumbersRange &range) {
     throw std::runtime_error{
         "Multiple value list for the 'y' attribute is not yet implemented"};
   }
-  m_svgAnalyzer->set_y(*range.begin());
+  m_svg_analyzer->set_y(*range.begin());
 }
 
 void SvgppContext::set(svgpp::tag::attribute::width, const double v) {
-  m_svgAnalyzer->set_width(v);
+  m_svg_analyzer->set_width(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::height, const double v) {
-  m_svgAnalyzer->set_height(v);
+  m_svg_analyzer->set_height(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::id,
                        boost::iterator_range<const char *> v) {
-  m_svgAnalyzer->set_id({v.begin(), v.end()});
+  m_svg_analyzer->set_id({v.begin(), v.end()});
 }
 
 void SvgppContext::set(svgpp::tag::attribute::class_,
                        boost::iterator_range<const char *> v) {
-  m_svgAnalyzer->set_class({v.begin(), v.end()});
+  m_svg_analyzer->set_class({v.begin(), v.end()});
 }
 
 void SvgppContext::set(svgpp::tag::attribute::font_family,
                        boost::iterator_range<const char *> v) {
-  m_svgAnalyzer->set_font_family({v.begin(), v.end()});
+  m_svg_analyzer->set_font_family({v.begin(), v.end()});
 }
 
 void SvgppContext::set(svgpp::tag::attribute::font_size, const double v) {
-  m_svgAnalyzer->set_font_size(v);
+  m_svg_analyzer->set_font_size(v);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::font_size,
@@ -287,31 +287,31 @@ void SvgppContext::set(svgpp::tag::attribute::font_size,
 
 void SvgppContext::set(svgpp::tag::attribute::text_anchor,
                        svgpp::tag::value::start) {
-  m_svgAnalyzer->set_text_anchor("start");
+  m_svg_analyzer->set_text_anchor("start");
 }
 
 void SvgppContext::set(svgpp::tag::attribute::text_anchor,
                        svgpp::tag::value::middle) {
-  m_svgAnalyzer->set_text_anchor("middle");
+  m_svg_analyzer->set_text_anchor("middle");
 }
 
 void SvgppContext::set(svgpp::tag::attribute::text_anchor,
                        svgpp::tag::value::end) {
-  m_svgAnalyzer->set_text_anchor("end");
+  m_svg_analyzer->set_text_anchor("end");
 }
 
 void SvgppContext::set(svgpp::tag::attribute::viewBox, const double v1,
                        const double v2, const double v3, const double v4) {
-  m_svgAnalyzer->set_viewBox(v1, v2, v3, v4);
+  m_svg_analyzer->set_viewBox(v1, v2, v3, v4);
 }
 
 void SvgppContext::set(svgpp::tag::attribute::points,
                        const SvgppContext::PointsRange &range) {
   for (auto &it : range) {
-    m_svgAnalyzer->set_point(it);
+    m_svg_analyzer->set_point(it);
   }
 }
 
 void SvgppContext::set_text(boost::iterator_range<const char *> v) {
-  m_svgAnalyzer->set_text({v.begin(), v.end()});
+  m_svg_analyzer->set_text({v.begin(), v.end()});
 }

diff --git a/tests/svgpp_context.h b/tests/svgpp_context.h
index 828e26fc19dd5b39214fddacf32084f9df198de9..fdf5da37861781db1592df8174f4461aab2977c0 100644 (file)
--- a/tests/svgpp_context.h
+++ b/tests/svgpp_context.h
@@ -22,7 +22,7 @@ class ISVGAnalyzer;
 
 class SvgppContext {
 public:
-  SvgppContext(ISVGAnalyzer *svgAnalyzer);
+  SvgppContext(ISVGAnalyzer *svg_analyzer);
   void on_enter_element(svgpp::tag::element::svg e);
   void on_enter_element(svgpp::tag::element::g e);
   void on_enter_element(svgpp::tag::element::circle e);
@@ -194,5 +194,5 @@ public:
   void set_text(boost::iterator_range<const char *> v);
 
 private:
-  ISVGAnalyzer *m_svgAnalyzer = nullptr;
+  ISVGAnalyzer *m_svg_analyzer = nullptr;
 };

diff --git a/tests/test_GVContext_render_svg.cpp b/tests/test_GVContext_render_svg.cpp
index 6e3d1b995c6ab41caeb9d2e9601afbb4373cfed4..047b98a5bbc213590e2908d566ffc1744b4a367c 100644 (file)
--- a/tests/test_GVContext_render_svg.cpp
+++ b/tests/test_GVContext_render_svg.cpp
@@ -20,17 +20,17 @@ TEST_CASE(
   const auto layout = GVC::GVLayout(std::move(gvc), std::move(g), "dot");
 
   const auto result = layout.render("svg");
-  SVGAnalyzer svgAnalyzer{result.c_str()};
-  REQUIRE(svgAnalyzer.num_svgs() == 1);
-  REQUIRE(svgAnalyzer.num_groups() == 1);
-  REQUIRE(svgAnalyzer.num_circles() == 0);
-  REQUIRE(svgAnalyzer.num_ellipses() == 0);
-  REQUIRE(svgAnalyzer.num_lines() == 0);
-  REQUIRE(svgAnalyzer.num_paths() == 0);
-  REQUIRE(svgAnalyzer.num_polygons() == 1);
-  REQUIRE(svgAnalyzer.num_polylines() == 0);
-  REQUIRE(svgAnalyzer.num_rects() == 0);
-  REQUIRE(svgAnalyzer.num_titles() == 0);
+  SVGAnalyzer svg_analyzer{result.c_str()};
+  REQUIRE(svg_analyzer.num_svgs() == 1);
+  REQUIRE(svg_analyzer.num_groups() == 1);
+  REQUIRE(svg_analyzer.num_circles() == 0);
+  REQUIRE(svg_analyzer.num_ellipses() == 0);
+  REQUIRE(svg_analyzer.num_lines() == 0);
+  REQUIRE(svg_analyzer.num_paths() == 0);
+  REQUIRE(svg_analyzer.num_polygons() == 1);
+  REQUIRE(svg_analyzer.num_polylines() == 0);
+  REQUIRE(svg_analyzer.num_rects() == 0);
+  REQUIRE(svg_analyzer.num_titles() == 0);
 }
 
 TEST_CASE("Rendering an SVG from a graph with a single node outputs an SVG "
@@ -44,17 +44,17 @@ TEST_CASE("Rendering an SVG from a graph with a single node outputs an SVG "
   const auto layout = GVC::GVLayout(std::move(gvc), std::move(g), "dot");
 
   const auto result = layout.render("svg");
-  SVGAnalyzer svgAnalyzer{result.c_str()};
-  REQUIRE(svgAnalyzer.num_svgs() == 1);
-  REQUIRE(svgAnalyzer.num_groups() == 2);
-  REQUIRE(svgAnalyzer.num_ellipses() == 1);
-  REQUIRE(svgAnalyzer.num_circles() == 0);
-  REQUIRE(svgAnalyzer.num_lines() == 0);
-  REQUIRE(svgAnalyzer.num_paths() == 0);
-  REQUIRE(svgAnalyzer.num_polygons() == 1);
-  REQUIRE(svgAnalyzer.num_polylines() == 0);
-  REQUIRE(svgAnalyzer.num_rects() == 0);
-  REQUIRE(svgAnalyzer.num_titles() == 1);
+  SVGAnalyzer svg_analyzer{result.c_str()};
+  REQUIRE(svg_analyzer.num_svgs() == 1);
+  REQUIRE(svg_analyzer.num_groups() == 2);
+  REQUIRE(svg_analyzer.num_ellipses() == 1);
+  REQUIRE(svg_analyzer.num_circles() == 0);
+  REQUIRE(svg_analyzer.num_lines() == 0);
+  REQUIRE(svg_analyzer.num_paths() == 0);
+  REQUIRE(svg_analyzer.num_polygons() == 1);
+  REQUIRE(svg_analyzer.num_polylines() == 0);
+  REQUIRE(svg_analyzer.num_rects() == 0);
+  REQUIRE(svg_analyzer.num_titles() == 1);
 }
 
 TEST_CASE("Rendering an SVG from a graph with two nodes outputs an SVG "
@@ -68,17 +68,17 @@ TEST_CASE("Rendering an SVG from a graph with two nodes outputs an SVG "
   const auto layout = GVC::GVLayout(std::move(gvc), std::move(g), "dot");
 
   const auto result = layout.render("svg");
-  SVGAnalyzer svgAnalyzer{result.c_str()};
-  REQUIRE(svgAnalyzer.num_svgs() == 1);
-  REQUIRE(svgAnalyzer.num_groups() == 3);
-  REQUIRE(svgAnalyzer.num_ellipses() == 2);
-  REQUIRE(svgAnalyzer.num_circles() == 0);
-  REQUIRE(svgAnalyzer.num_lines() == 0);
-  REQUIRE(svgAnalyzer.num_paths() == 0);
-  REQUIRE(svgAnalyzer.num_polygons() == 1);
-  REQUIRE(svgAnalyzer.num_polylines() == 0);
-  REQUIRE(svgAnalyzer.num_rects() == 0);
-  REQUIRE(svgAnalyzer.num_titles() == 2);
+  SVGAnalyzer svg_analyzer{result.c_str()};
+  REQUIRE(svg_analyzer.num_svgs() == 1);
+  REQUIRE(svg_analyzer.num_groups() == 3);
+  REQUIRE(svg_analyzer.num_ellipses() == 2);
+  REQUIRE(svg_analyzer.num_circles() == 0);
+  REQUIRE(svg_analyzer.num_lines() == 0);
+  REQUIRE(svg_analyzer.num_paths() == 0);
+  REQUIRE(svg_analyzer.num_polygons() == 1);
+  REQUIRE(svg_analyzer.num_polylines() == 0);
+  REQUIRE(svg_analyzer.num_rects() == 0);
+  REQUIRE(svg_analyzer.num_titles() == 2);
 }
 
 TEST_CASE("Rendering an SVG from a graph with two nodes and one edge outputs "
@@ -92,15 +92,15 @@ TEST_CASE("Rendering an SVG from a graph with two nodes and one edge outputs "
   const auto layout = GVC::GVLayout(std::move(gvc), std::move(g), "dot");
 
   const auto result = layout.render("svg");
-  SVGAnalyzer svgAnalyzer{result.c_str()};
-  REQUIRE(svgAnalyzer.num_svgs() == 1);
-  REQUIRE(svgAnalyzer.num_groups() == 4);
-  REQUIRE(svgAnalyzer.num_ellipses() == 2);
-  REQUIRE(svgAnalyzer.num_circles() == 0);
-  REQUIRE(svgAnalyzer.num_lines() == 0);
-  REQUIRE(svgAnalyzer.num_paths() == 1);
-  REQUIRE(svgAnalyzer.num_polygons() == 2);
-  REQUIRE(svgAnalyzer.num_polylines() == 0);
-  REQUIRE(svgAnalyzer.num_rects() == 0);
-  REQUIRE(svgAnalyzer.num_titles() == 3);
+  SVGAnalyzer svg_analyzer{result.c_str()};
+  REQUIRE(svg_analyzer.num_svgs() == 1);
+  REQUIRE(svg_analyzer.num_groups() == 4);
+  REQUIRE(svg_analyzer.num_ellipses() == 2);
+  REQUIRE(svg_analyzer.num_circles() == 0);
+  REQUIRE(svg_analyzer.num_lines() == 0);
+  REQUIRE(svg_analyzer.num_paths() == 1);
+  REQUIRE(svg_analyzer.num_polygons() == 2);
+  REQUIRE(svg_analyzer.num_polylines() == 0);
+  REQUIRE(svg_analyzer.num_rects() == 0);
+  REQUIRE(svg_analyzer.num_titles() == 3);
 }

diff --git a/tests/test_rankdir.cpp b/tests/test_rankdir.cpp
index 5c5b65a515dcc1e52912a5967869960428788bd8..7e17c37c7ea1ff5be76be2954a1c74fb491edcd6 100644 (file)
--- a/tests/test_rankdir.cpp
+++ b/tests/test_rankdir.cpp
@@ -35,10 +35,10 @@ TEST_CASE("Graph rankdir", "Test that the Graphviz `rankdir` attribute affects "
   const auto layout = GVC::GVLayout(std::move(gvc), std::move(g), "dot");
 
   const auto result = layout.render("svg");
-  SVGAnalyzer svgAnalyzer{result.c_str()};
+  SVGAnalyzer svg_analyzer{result.c_str()};
 
-  REQUIRE(svgAnalyzer.graphs().size() == 1);
-  const auto &graph = svgAnalyzer.graphs().back();
+  REQUIRE(svg_analyzer.graphs().size() == 1);
+  const auto &graph = svg_analyzer.graphs().back();
   const auto node_a = graph.node("a");
   const auto node_b = graph.node("b");
   const auto edge_ab = graph.edge("a->b");

diff --git a/tests/test_svg_analyzer.cpp b/tests/test_svg_analyzer.cpp
index 6d3e282b9a4356ade3db7eafecfcbce95c935576..b2b54c9cd146391814a9e997db8a1f031c2e4399 100644 (file)
--- a/tests/test_svg_analyzer.cpp
+++ b/tests/test_svg_analyzer.cpp
@@ -35,16 +35,16 @@ TEST_CASE(
 
   const auto result = layout.render("svg");
   const std::string original_svg{result.string_view()};
-  SVGAnalyzer svgAnalyzer{result.c_str()};
-  svgAnalyzer.set_graphviz_version(graphviz_version);
-  svgAnalyzer.set_graphviz_build_date(graphviz_build_date);
+  SVGAnalyzer svg_analyzer{result.c_str()};
+  svg_analyzer.set_graphviz_version(graphviz_version);
+  svg_analyzer.set_graphviz_build_date(graphviz_build_date);
 
   const std::size_t expected_num_graphs = 1;
   const std::size_t expected_num_nodes = 2;
   const std::size_t expected_num_edges = 1;
 
-  CHECK(svgAnalyzer.graphs().size() == expected_num_graphs);
-  for (const auto &graph : svgAnalyzer.graphs()) {
+  CHECK(svg_analyzer.graphs().size() == expected_num_graphs);
+  for (const auto &graph : svg_analyzer.graphs()) {
     CHECK(graph.svg_g_element().type == SVG::SVGElementType::Group);
     CHECK(graph.svg_g_element().attributes.class_ == "graph");
     CHECK(graph.svg_g_element().graphviz_id == "g1");
@@ -124,20 +124,20 @@ TEST_CASE(
     const std::size_t expected_num_texts =
         shape == "point" ? 0 : expected_num_nodes;
 
-    CHECK(svgAnalyzer.num_svgs() == expected_num_svgs);
-    CHECK(svgAnalyzer.num_groups() == expected_num_groups);
-    CHECK(svgAnalyzer.num_circles() == expected_num_circles);
-    CHECK(svgAnalyzer.num_ellipses() == expected_num_ellipses);
-    CHECK(svgAnalyzer.num_lines() == expected_num_lines);
-    CHECK(svgAnalyzer.num_paths() == expected_num_paths);
-    CHECK(svgAnalyzer.num_polygons() == expected_num_polygons);
-    CHECK(svgAnalyzer.num_polylines() == expected_num_polylines);
-    CHECK(svgAnalyzer.num_rects() == expected_num_rects);
-    CHECK(svgAnalyzer.num_titles() == expected_num_titles);
-    CHECK(svgAnalyzer.num_texts() == expected_num_texts);
+    CHECK(svg_analyzer.num_svgs() == expected_num_svgs);
+    CHECK(svg_analyzer.num_groups() == expected_num_groups);
+    CHECK(svg_analyzer.num_circles() == expected_num_circles);
+    CHECK(svg_analyzer.num_ellipses() == expected_num_ellipses);
+    CHECK(svg_analyzer.num_lines() == expected_num_lines);
+    CHECK(svg_analyzer.num_paths() == expected_num_paths);
+    CHECK(svg_analyzer.num_polygons() == expected_num_polygons);
+    CHECK(svg_analyzer.num_polylines() == expected_num_polylines);
+    CHECK(svg_analyzer.num_rects() == expected_num_rects);
+    CHECK(svg_analyzer.num_titles() == expected_num_titles);
+    CHECK(svg_analyzer.num_texts() == expected_num_texts);
 
     const auto indent_size = 0;
-    auto recreated_svg = svgAnalyzer.svg_string(indent_size);
+    auto recreated_svg = svg_analyzer.svg_string(indent_size);
 
     // compare the recreated SVG with the original SVG
     if (recreated_svg != original_svg) {