[node, tests] Consolidate headless rendering logic in HeadlessFrontend

4 files changed, 55 insertions, 83 deletions

diff --git a/test/api/annotations.test.cpp b/test/api/annotations.test.cpp
index 878ef90831..d6476f9a3e 100644
--- a/test/api/annotations.test.cpp
+++ b/test/api/annotations.test.cpp
@@ -6,14 +6,11 @@
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/map/map.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/gl/headless_backend.hpp>
-#include <mbgl/gl/offscreen_view.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/renderer/renderer.hpp>
-#include <mbgl/test/stub_renderer_frontend.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
 
 using namespace mbgl;
 
@@ -30,19 +27,16 @@ std::unique_ptr<style::Image> namedMarker(const std::string& name) {
 class AnnotationTest {
 public:
     util::RunLoop loop;
-    HeadlessBackend backend;
-    BackendScope scope { backend };
-    OffscreenView view { backend.getContext() };
     StubFileSource fileSource;
     ThreadPool threadPool { 4 };
     float pixelRatio { 1 };
-    StubRendererFrontend rendererFrontend { std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view };
-    Map map { rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource,
+    HeadlessFrontend frontend { pixelRatio, fileSource, threadPool };
+    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
               threadPool, MapMode::Still };
 
     void checkRendering(const char * name) {
         test::checkImage(std::string("test/fixtures/annotations/") + name,
-                         test::render(map, view), 0.0002, 0.1);
+                         frontend.render(map), 0.0002, 0.1);
     }
 };
 
@@ -160,7 +154,7 @@ TEST(Annotations, AddMultiple) {
     test.map.addAnnotationImage(namedMarker("default_marker"));
     test.map.addAnnotation(SymbolAnnotation { Point<double> { -10, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.addAnnotation(SymbolAnnotation { Point<double> { 10, 0 }, "default_marker" });
     test.checkRendering("add_multiple");
@@ -170,7 +164,7 @@ TEST(Annotations, NonImmediateAdd) {
     AnnotationTest test;
 
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     Polygon<double> polygon = { {{ { 0, 0 }, { 0, 45 }, { 45, 45 }, { 45, 0 } }} };
     FillAnnotation annotation { polygon };
@@ -188,7 +182,7 @@ TEST(Annotations, UpdateSymbolAnnotationGeometry) {
     test.map.addAnnotationImage(namedMarker("flipped_marker"));
     AnnotationID point = test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.updateAnnotation(point, SymbolAnnotation { Point<double> { -10, 0 }, "default_marker" });
     test.checkRendering("update_point");
@@ -202,7 +196,7 @@ TEST(Annotations, UpdateSymbolAnnotationIcon) {
     test.map.addAnnotationImage(namedMarker("flipped_marker"));
     AnnotationID point = test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.updateAnnotation(point, SymbolAnnotation { Point<double> { 0, 0 }, "flipped_marker" });
     test.checkRendering("update_icon");
@@ -218,7 +212,7 @@ TEST(Annotations, UpdateLineAnnotationGeometry) {
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     AnnotationID line = test.map.addAnnotation(annotation);
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     annotation.geometry = LineString<double> {{ { 0, 0 }, { -45, -45 } }};
     test.map.updateAnnotation(line, annotation);
@@ -235,7 +229,7 @@ TEST(Annotations, UpdateLineAnnotationStyle) {
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     AnnotationID line = test.map.addAnnotation(annotation);
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     annotation.color = Color::green();
     annotation.width = { 2 };
@@ -252,7 +246,7 @@ TEST(Annotations, UpdateFillAnnotationGeometry) {
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     AnnotationID fill = test.map.addAnnotation(annotation);
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     annotation.geometry = Polygon<double> { {{ { 0, 0 }, { 0, 45 }, { 45, 0 } }} };
     test.map.updateAnnotation(fill, annotation);
@@ -269,7 +263,7 @@ TEST(Annotations, UpdateFillAnnotationStyle) {
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     AnnotationID fill = test.map.addAnnotation(annotation);
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     annotation.color = Color::green();
     test.map.updateAnnotation(fill, annotation);
@@ -283,7 +277,7 @@ TEST(Annotations, RemovePoint) {
     test.map.addAnnotationImage(namedMarker("default_marker"));
     AnnotationID point = test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.removeAnnotation(point);
     test.checkRendering("remove_point");
@@ -300,7 +294,7 @@ TEST(Annotations, RemoveShape) {
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     AnnotationID shape = test.map.addAnnotation(annotation);
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.removeAnnotation(shape);
     test.checkRendering("remove_shape");
@@ -312,7 +306,7 @@ TEST(Annotations, ImmediateRemoveShape) {
     test.map.removeAnnotation(test.map.addAnnotation(LineAnnotation { LineString<double>() }));
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 }
 
 TEST(Annotations, SwitchStyle) {
@@ -322,7 +316,7 @@ TEST(Annotations, SwitchStyle) {
     test.map.addAnnotationImage(namedMarker("default_marker"));
     test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
     test.checkRendering("switch_style");
@@ -335,7 +329,7 @@ TEST(Annotations, ReaddImage) {
     test.map.addAnnotationImage(namedMarker("default_marker"));
     test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
     test.map.addAnnotationImage(std::make_unique<style::Image>("default_marker", namedImage("flipped_marker"), 1.0));
     test.checkRendering("readd_image");
@@ -349,14 +343,14 @@ TEST(Annotations, QueryRenderedFeatures) {
     test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 0 }, "default_marker" });
     test.map.addAnnotation(SymbolAnnotation { Point<double> { 0, 50 }, "default_marker" });
 
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
-    auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 }));
+    auto features = test.frontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 }));
     EXPECT_EQ(features.size(), 1u);
     EXPECT_TRUE(!!features[0].id);
     EXPECT_EQ(*features[0].id, uint64_t(0));
 
-    auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 50, 0 }));
+    auto features2 = test.frontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 50, 0 }));
     EXPECT_EQ(features2.size(), 1u);
     EXPECT_TRUE(!!features2[0].id);
     EXPECT_EQ(*features2[0].id, uint64_t(1));
@@ -365,7 +359,7 @@ TEST(Annotations, QueryRenderedFeatures) {
 TEST(Annotations, QueryFractionalZoomLevels) {
     AnnotationTest test;
 
-    auto viewSize = test.view.getSize();
+    auto viewSize = test.frontend.getSize();
     auto box = ScreenBox { {}, { double(viewSize.width), double(viewSize.height) } };
 
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
@@ -381,8 +375,8 @@ TEST(Annotations, QueryFractionalZoomLevels) {
     test.map.setLatLngZoom({ 5, 5 }, 0);
     for (uint16_t zoomSteps = 10; zoomSteps <= 20; ++zoomSteps) {
         test.map.setZoom(zoomSteps / 10.0);
-        test::render(test.map, test.view);
-        auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box);
+        test.frontend.render(test.map);
+        auto features = test.frontend.getRenderer()->queryRenderedFeatures(box);
 
         // Filter out repeated features.
         // See 'edge-cases/null-island' query-test for reference.
@@ -397,7 +391,7 @@ TEST(Annotations, QueryFractionalZoomLevels) {
 TEST(Annotations, VisibleFeatures) {
     AnnotationTest test;
 
-    auto viewSize = test.view.getSize();
+    auto viewSize = test.frontend.getSize();
     auto box = ScreenBox { {}, { double(viewSize.width), double(viewSize.height) } };
 
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
@@ -413,9 +407,9 @@ TEST(Annotations, VisibleFeatures) {
 
     // Change bearing *after* adding annotations causes them to be reordered.
     test.map.setBearing(45);
-    test::render(test.map, test.view);
+    test.frontend.render(test.map);
 
-    auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box, {});
+    auto features = test.frontend.getRenderer()->queryRenderedFeatures(box, {});
     auto sortID = [](const Feature& lhs, const Feature& rhs) { return lhs.id < rhs.id; };
     auto sameID = [](const Feature& lhs, const Feature& rhs) { return lhs.id == rhs.id; };
     std::sort(features.begin(), features.end(), sortID);
@@ -424,8 +418,8 @@ TEST(Annotations, VisibleFeatures) {
 
     test.map.setBearing(0);
     test.map.setZoom(4);
-    test::render(test.map, test.view);
-    features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box);
+    test.frontend.render(test.map);
+    features = test.frontend.getRenderer()->queryRenderedFeatures(box);
     std::sort(features.begin(), features.end(), sortID);
     features.erase(std::unique(features.begin(), features.end(), sameID), features.end());
     EXPECT_EQ(features.size(), ids.size());
diff --git a/test/api/api_misuse.test.cpp b/test/api/api_misuse.test.cpp
index 9f53b763be..690c1548e5 100644
--- a/test/api/api_misuse.test.cpp
+++ b/test/api/api_misuse.test.cpp
@@ -4,11 +4,8 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/gl/headless_backend.hpp>
-#include <mbgl/gl/offscreen_view.hpp>
-#include <mbgl/test/stub_renderer_frontend.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/storage/online_file_source.hpp>
-#include <mbgl/renderer/renderer.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/run_loop.hpp>
@@ -24,16 +21,12 @@ TEST(API, RenderWithoutCallback) {
 
     util::RunLoop loop;
 
-    HeadlessBackend backend;
-    BackendScope scope { backend };
-    OffscreenView view { backend.getContext(), { 128, 512 } };
     StubFileSource fileSource;
     ThreadPool threadPool(4);
     float pixelRatio { 1 };
-    StubRendererFrontend rendererFrontend {
-            std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view };
+    HeadlessFrontend frontend { pixelRatio, fileSource, threadPool };
 
-    auto map = std::make_unique<Map>(rendererFrontend, MapObserver::nullObserver(), view.getSize(),
+    auto map = std::make_unique<Map>(frontend, MapObserver::nullObserver(), frontend.getSize(),
                                      pixelRatio, fileSource, threadPool, MapMode::Still);
     map->renderStill(nullptr);
 
diff --git a/test/api/custom_layer.test.cpp b/test/api/custom_layer.test.cpp
index 972485338f..1c514aeca2 100644
--- a/test/api/custom_layer.test.cpp
+++ b/test/api/custom_layer.test.cpp
@@ -2,16 +2,12 @@
 
 #include <mbgl/gl/gl.hpp>
 #include <mbgl/map/map.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/gl/headless_backend.hpp>
-#include <mbgl/gl/offscreen_view.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
 #include <mbgl/storage/default_file_source.hpp>
-#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/style/layers/fill_layer.hpp>
-#include <mbgl/test/stub_renderer_frontend.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/run_loop.hpp>
@@ -89,14 +85,11 @@ public:
 TEST(CustomLayer, Basic) {
     util::RunLoop loop;
 
-    HeadlessBackend backend;
-    BackendScope scope { backend };
-    OffscreenView view { backend.getContext() };
     DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
     ThreadPool threadPool(4);
     float pixelRatio { 1 };
-    StubRendererFrontend rendererFrontend { std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view };
-    Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource,
+    HeadlessFrontend frontend { pixelRatio, fileSource, threadPool };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
             threadPool, MapMode::Still);
     map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
     map.setLatLngZoom({ 37.8, -122.5 }, 10);
@@ -117,6 +110,5 @@ TEST(CustomLayer, Basic) {
     layer->setFillColor(Color{ 1.0, 1.0, 0.0, 1.0 });
     map.getStyle().addLayer(std::move(layer));
 
-    test::checkImage("test/fixtures/custom_layer/basic", test::render(map, view), 0.0006, 0.1);
-
+    test::checkImage("test/fixtures/custom_layer/basic", frontend.render(map), 0.0006, 0.1);
 }
diff --git a/test/api/query.test.cpp b/test/api/query.test.cpp
index a5224222cb..3f3825eb72 100644
--- a/test/api/query.test.cpp
+++ b/test/api/query.test.cpp
@@ -1,7 +1,4 @@
 #include <mbgl/map/map.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/gl/headless_backend.hpp>
-#include <mbgl/gl/offscreen_view.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
 #include <mbgl/test/stub_file_source.hpp>
 #include <mbgl/test/util.hpp>
@@ -12,7 +9,7 @@
 #include <mbgl/style/image.hpp>
 #include <mbgl/style/source.hpp>
 #include <mbgl/renderer/renderer.hpp>
-#include <mbgl/test/stub_renderer_frontend.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
 
 using namespace mbgl;
 using namespace mbgl::style;
@@ -26,19 +23,15 @@ public:
         map.getStyle().addImage(std::make_unique<style::Image>("test-icon",
             decodeImage(util::read_file("test/fixtures/sprites/default_marker.png")), 1.0));
 
-        test::render(map, view);
+        frontend.render(map);
     }
 
     util::RunLoop loop;
-    HeadlessBackend backend;
-    BackendScope scope { backend };
-    OffscreenView view { backend.getContext() };
     StubFileSource fileSource;
     ThreadPool threadPool { 4 };
     float pixelRatio { 1 };
-    StubRendererFrontend rendererFrontend {
-            std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view };
-    Map map { rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource,
+    HeadlessFrontend frontend { pixelRatio, fileSource, threadPool };
+    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
               threadPool, MapMode::Still };
 };
 
@@ -47,10 +40,10 @@ public:
 TEST(Query, QueryRenderedFeatures) {
     QueryTest test;
 
-    auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 }));
+    auto features1 = test.frontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 }));
     EXPECT_EQ(features1.size(), 4u);
 
-    auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 9, 9 }));
+    auto features2 = test.frontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 9, 9 }));
     EXPECT_EQ(features2.size(), 0u);
 }
 
@@ -59,16 +52,16 @@ TEST(Query, QueryRenderedFeaturesFilterLayer) {
 
     auto zz = test.map.pixelForLatLng({ 0, 0 });
 
-    auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1"}}, {}});
+    auto features1 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1"}}, {}});
     EXPECT_EQ(features1.size(), 1u);
 
-    auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1", "layer2" }}, {}});
+    auto features2 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1", "layer2" }}, {}});
     EXPECT_EQ(features2.size(), 2u);
 
-    auto features3 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar" }}, {}});
+    auto features3 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar" }}, {}});
     EXPECT_EQ(features3.size(), 0u);
 
-    auto features4 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar", "layer3" }}, {}});
+    auto features4 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar", "layer3" }}, {}});
     EXPECT_EQ(features4.size(), 1u);
 }
 
@@ -78,22 +71,22 @@ TEST(Query, QueryRenderedFeaturesFilter) {
     auto zz = test.map.pixelForLatLng({ 0, 0 });
 
     const EqualsFilter eqFilter = { "key1", std::string("value1") };
-    auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{}, { eqFilter }});
+    auto features1 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{}, { eqFilter }});
     EXPECT_EQ(features1.size(), 1u);
 
     const IdentifierNotEqualsFilter idNotEqFilter = { std::string("feature1") };
-    auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer4" }}, { idNotEqFilter }});
+    auto features2 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer4" }}, { idNotEqFilter }});
     EXPECT_EQ(features2.size(), 0u);
 
     const GreaterThanFilter gtFilter = { "key2", 1.0 };
-    auto features3 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{ }, { gtFilter }});
+    auto features3 = test.frontend.getRenderer()->queryRenderedFeatures(zz, {{ }, { gtFilter }});
     EXPECT_EQ(features3.size(), 1u);
 }
 
 TEST(Query, QuerySourceFeatures) {
     QueryTest test;
 
-    auto features1 = test.rendererFrontend.getRenderer()->querySourceFeatures("source3");
+    auto features1 = test.frontend.getRenderer()->querySourceFeatures("source3");
     EXPECT_EQ(features1.size(), 1u);
 }
 
@@ -101,15 +94,15 @@ TEST(Query, QuerySourceFeaturesOptionValidation) {
     QueryTest test;
 
     // GeoJSONSource, doesn't require a layer id
-    auto features = test.rendererFrontend.getRenderer()->querySourceFeatures("source3");
+    auto features = test.frontend.getRenderer()->querySourceFeatures("source3");
     ASSERT_EQ(features.size(), 1u);
 
     // VectorSource, requires a layer id
-    features = test.rendererFrontend.getRenderer()->querySourceFeatures("source5");
+    features = test.frontend.getRenderer()->querySourceFeatures("source5");
     ASSERT_EQ(features.size(), 0u);
     
     // RasterSource, not supported
-    features = test.rendererFrontend.getRenderer()->querySourceFeatures("source6");
+    features = test.frontend.getRenderer()->querySourceFeatures("source6");
     ASSERT_EQ(features.size(), 0u);
 }
 
@@ -117,15 +110,15 @@ TEST(Query, QuerySourceFeaturesFilter) {
     QueryTest test;
 
     const EqualsFilter eqFilter = { "key1", std::string("value1") };
-    auto features1 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { eqFilter }});
+    auto features1 = test.frontend.getRenderer()->querySourceFeatures("source4", {{}, { eqFilter }});
     EXPECT_EQ(features1.size(), 1u);
 
     const IdentifierNotEqualsFilter idNotEqFilter = { std::string("feature1") };
-    auto features2 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { idNotEqFilter }});
+    auto features2 = test.frontend.getRenderer()->querySourceFeatures("source4", {{}, { idNotEqFilter }});
     EXPECT_EQ(features2.size(), 0u);
 
     const GreaterThanFilter gtFilter = { "key2", 1.0 };
-    auto features3 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { gtFilter }});
+    auto features3 = test.frontend.getRenderer()->querySourceFeatures("source4", {{}, { gtFilter }});
     EXPECT_EQ(features3.size(), 1u);
 }