starboard: Add tests for Starboard Extension for Features

This PR adds testing for the Starboard Extension that adds Chromium
Features to the Starboard level.

An extension_test is added to check that the extension api itself is
retrievable. We also add `features_extension_test.cc`, which tests the
usage of hte starboard::features::FeatureList class. This class is what
intializes and stores features and parameters that are used in the
Starboard level.

Currently, these tests do not run on CI as their test build target,
starboard_platform_tests, is not built.

Bug: 435467391

Author: johnedocampo

starboard/android/shared/BUILD.gn

@@ -403,6 +403,7 @@ source_set("starboard_platform_tests") {
   sources = media_tests_sources + player_tests_sources + [
               "//starboard/shared/starboard/drm/drm_test_helpers.cc",
               "//starboard/shared/starboard/drm/drm_test_helpers.h",
+              "features_extension_test.cc",
               "jni_env_ext_test.cc",
               "model_year_test.cc",
               "player_get_preferred_output_mode_test.cc",

starboard/android/shared/features_extension_test.cc

@@ -0,0 +1,125 @@
+// Copyright 2025 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/android/shared/features_extension.h"
+
+#include <any>
+#include <iterator>
+#include <variant>
+
+#include "starboard/shared/starboard/feature_list.h"
+#include "starboard/shared/starboard/features.h"
+#include "starboard/system.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard::android::shared {
+namespace {
+using starboard::features::FeatureList;
+using starboard::features::SbFeatureParamExt;
+
+using ParamValue = std::variant<bool, int, double, std::string, int64_t>;
+
+const SbFeature FeatureTestBoolTrue = {"FeatureTestBoolTrue", true};
+const SbFeature FeatureTestBoolFalse = {"FeatureTestBoolFalse", false};
+
+const SbFeatureParam ParamTestBool = {"FeatureTestBoolTrue",
+                                      "ParamBool",
+                                      SbFeatureParamTypeBool,
+                                      {.bool_value = true}};
+const SbFeatureParam ParamTestInt = {"FeatureTestBoolTrue",
+                                     "ParamInt",
+                                     SbFeatureParamTypeInt,
+                                     {.int_value = 10}};
+const SbFeatureParam ParamTestDouble = {"FeatureTestBoolTrue",
+                                        "ParamDouble",
+                                        SbFeatureParamTypeDouble,
+                                        {.double_value = 3.14}};
+const SbFeatureParam ParamTestString = {"FeatureTestBoolTrue",
+                                        "ParamString",
+                                        SbFeatureParamTypeString,
+                                        {.string_value = "Sunny day"}};
+const SbFeatureParam ParamTestTime = {"FeatureTestBoolTrue",
+                                      "ParamTime",
+                                      SbFeatureParamTypeTime,
+                                      {.time_value = 123456789}};
+
+const SbFeature features[] = {FeatureTestBoolTrue, FeatureTestBoolFalse};
+const SbFeatureParam params[] = {ParamTestBool, ParamTestInt, ParamTestDouble,
+                                 ParamTestString, ParamTestTime};
+
+struct ParamTestCase {
+  std::string test_name;
+  SbFeatureParam param_definition;
+  ParamValue expected_value;
+};
+
+}  // namespace
+
+class FeatureExtensionTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    const StarboardExtensionFeaturesApi* extension_api =
+        static_cast<const StarboardExtensionFeaturesApi*>(
+            SbSystemGetExtension(kStarboardExtensionFeaturesName));
+
+    extension_api->InitializeStarboardFeatures(features, std::size(features),
+                                               params, std::size(params));
+  }
+};
+
+TEST_F(FeatureExtensionTest, CanAccessFeatures) {
+  EXPECT_TRUE(FeatureList::IsEnabled(FeatureTestBoolTrue));
+  EXPECT_FALSE(FeatureList::IsEnabled(FeatureTestBoolFalse));
+}
+
+class ParamExtensionTest : public ::testing::Test,
+                           public ::testing::WithParamInterface<ParamTestCase> {
+};
+
+TEST_P(ParamExtensionTest, CanAccessParams) {
+  const auto& test_case = GetParam();
+  const auto& param_def = test_case.param_definition;
+
+  // std::visit will select the right code to run based on the
+  // type currently held in the 'expected_value' variant.
+  std::visit(
+      [&](const auto& expected_value) {
+        // Get the type T from the expected_value (e.g., bool, int, ...)
+        using T = std::decay_t<decltype(expected_value)>;
+
+        // The logic is now generic and uses the deduced type T
+        auto key =
+            SbFeatureParamExt<T>(FeatureTestBoolTrue, param_def.param_name);
+        auto actual_value = FeatureList::GetParam(key);
+
+        EXPECT_EQ(actual_value, expected_value);
+      },
+      test_case.expected_value);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ParamTests,
+    ParamExtensionTest,
+    ::testing::Values(
+        ParamTestCase{"Bool", ParamTestBool, ParamTestBool.value.bool_value},
+        ParamTestCase{"Int", ParamTestInt, ParamTestInt.value.int_value},
+        ParamTestCase{"Double", ParamTestDouble,
+                      ParamTestDouble.value.double_value},
+        ParamTestCase{"String", ParamTestString,
+                      ParamTestString.value.string_value},
+        ParamTestCase{"Time", ParamTestTime, ParamTestTime.value.time_value}),
+    // This lambda tells gtest how to name each test case
+    [](const auto& info) { return info.param.test_name; });
+
+}  // namespace starboard::android::shared

starboard/extension/extension_test.cc

@@ -18,6 +18,7 @@
 #include "starboard/extension/configuration.h"
 #include "starboard/extension/crash_handler.h"
 #include "starboard/extension/enhanced_audio.h"
+#include "starboard/extension/features.h"
 #include "starboard/extension/font.h"
 #include "starboard/extension/free_space.h"
 #include "starboard/extension/graphics.h"
@@ -573,5 +574,25 @@ TEST(ExtensionTest, StarboardSystemInfoExtension) {
       << "Extension struct should be a singleton";
 }
 
+TEST(ExtensionTest, StarboardFeaturesExtension) {
+  typedef StarboardExtensionFeaturesApi ExtensionApi;
+  const char* kExtensionName = kStarboardExtensionFeaturesName;
+
+  const ExtensionApi* extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
+  if (!extension_api) {
+    return;
+  }
+
+  EXPECT_STREQ(extension_api->name, kExtensionName);
+  EXPECT_EQ(extension_api->version, 1u);
+  EXPECT_NE(extension_api->InitializeStarboardFeatures, nullptr);
+
+  const ExtensionApi* second_extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
+  EXPECT_EQ(second_extension_api, extension_api)
+      << "Extension struct should be a singleton";
+}
+
 }  // namespace extension
 }  // namespace starboard