Add base::FeatureParam<> struct

base/metrics/field_trial_params_unittest.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/metrics/field_trial_params.h"
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_param_associator.h"
@@ skipping 220 matching lines @@
   scoped_refptr<FieldTrial> trial(
       CreateFieldTrial(kTrialName, 100, "A", nullptr));
 
   CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
                          trial.get());
 
   std::map<std::string, std::string> actualParams;
   EXPECT_EQ(std::string(), GetFieldTrialParamValueByFeature(kFeature, "x"));
 }
 
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsInt) {
+TEST_F(FieldTrialParamsTest, FeatureParamString) {
   const std::string kTrialName = "GetFieldTrialParamsByFeature";
-  const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<std::string> a{&kFeature, "a", "default"};
+  static const FeatureParam<std::string> b{&kFeature, "b", ""};
+  static const FeatureParam<std::string> c{&kFeature, "c", "default"};
+  static const FeatureParam<std::string> d{&kFeature, "d", ""};
+  static const FeatureParam<std::string> e{&kFeature, "e", "default"};
+  static const FeatureParam<std::string> f{&kFeature, "f", ""};
+
+  std::map<std::string, std::string> params;
+  params["a"] = "";
+  params["b"] = "non-default";
+  params["c"] = "non-default";
+  params["d"] = "";
+  // "e" is not registered
+  // "f" is not registered
+  AssociateFieldTrialParams(kTrialName, "A", params);
+  scoped_refptr<FieldTrial> trial(
+      CreateFieldTrial(kTrialName, 100, "A", nullptr));
+
+  CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
+                         trial.get());
+
+  EXPECT_EQ("default", a.Get());  // empty
+  EXPECT_EQ("non-default", b.Get());
+  EXPECT_EQ("non-default", c.Get());
+  EXPECT_EQ("", d.Get());         // empty
+  EXPECT_EQ("default", e.Get());  // not registered
+  EXPECT_EQ("", f.Get());         // not registered
+}
+
+TEST_F(FieldTrialParamsTest, FeatureParamInt) {
+  const std::string kTrialName = "GetFieldTrialParamsByFeature";
+
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<int> a{&kFeature, "a", 0};
+  static const FeatureParam<int> b{&kFeature, "b", 0};
+  static const FeatureParam<int> c{&kFeature, "c", 0};
+  static const FeatureParam<int> d{&kFeature, "d", 0};
+  static const FeatureParam<int> e{&kFeature, "e", 0};
 
   std::map<std::string, std::string> params;
   params["a"] = "1";
   params["b"] = "1.5";
   params["c"] = "foo";
   params["d"] = "";
   // "e" is not registered
   AssociateFieldTrialParams(kTrialName, "A", params);
   scoped_refptr<FieldTrial> trial(
       CreateFieldTrial(kTrialName, 100, "A", nullptr));
 
   CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
                          trial.get());
 
-  std::map<std::string, std::string> actualParams;
   EXPECT_EQ(1, GetFieldTrialParamByFeatureAsInt(kFeature, "a", 0));
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "b", 0));  // invalid
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "c", 0));  // invalid
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "d", 0));  // empty
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "e", 0));  // empty
+
+  EXPECT_EQ(1, a.Get());
+  EXPECT_EQ(0, b.Get());  // invalid
+  EXPECT_EQ(0, c.Get());  // invalid
+  EXPECT_EQ(0, d.Get());  // empty
+  EXPECT_EQ(0, e.Get());  // empty
 }
 
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsDouble) {
+TEST_F(FieldTrialParamsTest, FeatureParamDouble) {
   const std::string kTrialName = "GetFieldTrialParamsByFeature";
-  const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<double> a{&kFeature, "a", 0.0};
+  static const FeatureParam<double> b{&kFeature, "b", 0.0};
+  static const FeatureParam<double> c{&kFeature, "c", 0.0};
+  static const FeatureParam<double> d{&kFeature, "d", 0.0};
+  static const FeatureParam<double> e{&kFeature, "e", 0.0};
+  static const FeatureParam<double> f{&kFeature, "f", 0.0};
 
   std::map<std::string, std::string> params;
   params["a"] = "1";
   params["b"] = "1.5";
   params["c"] = "1.0e-10";
   params["d"] = "foo";
   params["e"] = "";
   // "f" is not registered
   AssociateFieldTrialParams(kTrialName, "A", params);
   scoped_refptr<FieldTrial> trial(
       CreateFieldTrial(kTrialName, 100, "A", nullptr));
 
   CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
                          trial.get());
 
-  std::map<std::string, std::string> actualParams;
   EXPECT_EQ(1, GetFieldTrialParamByFeatureAsDouble(kFeature, "a", 0));
   EXPECT_EQ(1.5, GetFieldTrialParamByFeatureAsDouble(kFeature, "b", 0));
   EXPECT_EQ(1.0e-10, GetFieldTrialParamByFeatureAsDouble(kFeature, "c", 0));
   EXPECT_EQ(0,
             GetFieldTrialParamByFeatureAsDouble(kFeature, "d", 0));  // invalid
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "e", 0));  // empty
   EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "f", 0));  // empty
+
+  EXPECT_EQ(1, a.Get());
+  EXPECT_EQ(1.5, b.Get());
+  EXPECT_EQ(1.0e-10, c.Get());
+  EXPECT_EQ(0, d.Get());  // invalid
+  EXPECT_EQ(0, e.Get());  // empty
+  EXPECT_EQ(0, f.Get());  // empty
 }
 
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsBool) {
+TEST_F(FieldTrialParamsTest, FeatureParamBool) {
   const std::string kTrialName = "GetFieldTrialParamsByFeature";
-  const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<bool> a{&kFeature, "a", false};
+  static const FeatureParam<bool> b{&kFeature, "b", true};
+  static const FeatureParam<bool> c{&kFeature, "c", false};
+  static const FeatureParam<bool> d{&kFeature, "d", true};
+  static const FeatureParam<bool> e{&kFeature, "e", true};
+  static const FeatureParam<bool> f{&kFeature, "f", true};
 
   std::map<std::string, std::string> params;
   params["a"] = "true";
   params["b"] = "false";
   params["c"] = "1";
   params["d"] = "False";
   params["e"] = "";
   // "f" is not registered
   AssociateFieldTrialParams(kTrialName, "A", params);
   scoped_refptr<FieldTrial> trial(
       CreateFieldTrial(kTrialName, 100, "A", nullptr));
 
   CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
                          trial.get());
 
-  std::map<std::string, std::string> actualParams;
-  EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "a", false));
-  EXPECT_FALSE(GetFieldTrialParamByFeatureAsBool(kFeature, "b", true));
-  EXPECT_FALSE(
-      GetFieldTrialParamByFeatureAsBool(kFeature, "c", false));  // invalid
-  EXPECT_TRUE(
-      GetFieldTrialParamByFeatureAsBool(kFeature, "d", true));  // invalid
-  EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "e", true));  // empty
-  EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "f", true));  // empty
+  EXPECT_TRUE(a.Get());
+  EXPECT_FALSE(b.Get());
+  EXPECT_FALSE(c.Get());  // invalid
+  EXPECT_TRUE(d.Get());   // invalid
+  EXPECT_TRUE(e.Get());   // empty
+  EXPECT_TRUE(f.Get());   // empty
+}
+
+enum Hand { ROCK, PAPER, SCISSORS };
+
+TEST_F(FieldTrialParamsTest, FeatureParamEnum) {
+  const std::string kTrialName = "GetFieldTrialParamsByFeature";
+
+  static const FeatureParam<Hand>::Option hands[] = {
+      {ROCK, "rock"}, {PAPER, "paper"}, {SCISSORS, "scissors"}};
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<Hand> a{&kFeature, "a", ROCK, &hands};
+  static const FeatureParam<Hand> b{&kFeature, "b", ROCK, &hands};
+  static const FeatureParam<Hand> c{&kFeature, "c", ROCK, &hands};
+  static const FeatureParam<Hand> d{&kFeature, "d", ROCK, &hands};
+  static const FeatureParam<Hand> e{&kFeature, "e", PAPER, &hands};
+  static const FeatureParam<Hand> f{&kFeature, "f", SCISSORS, &hands};
+
+  std::map<std::string, std::string> params;
+  params["a"] = "rock";
+  params["b"] = "paper";
+  params["c"] = "scissors";
+  params["d"] = "lizard";
+  params["e"] = "";
+  // "f" is not registered
+  AssociateFieldTrialParams(kTrialName, "A", params);
+  scoped_refptr<FieldTrial> trial(
+      CreateFieldTrial(kTrialName, 100, "A", nullptr));
+
+  CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
+                         trial.get());
+
+  EXPECT_EQ(ROCK, a.Get());
+  EXPECT_EQ(PAPER, b.Get());
+  EXPECT_EQ(SCISSORS, c.Get());
+  EXPECT_EQ(ROCK, d.Get());      // invalid
+  EXPECT_EQ(PAPER, e.Get());     // invalid/empty
+  EXPECT_EQ(SCISSORS, f.Get());  // not registered
+}
+
+enum class UI { ONE_D, TWO_D, THREE_D };
+
+TEST_F(FieldTrialParamsTest, FeatureParamEnumClass) {
+  const std::string kTrialName = "GetFieldTrialParamsByFeature";
+
+  static const FeatureParam<UI>::Option uis[] = {
+      {UI::ONE_D, "1d"}, {UI::TWO_D, "2d"}, {UI::THREE_D, "3d"}};
+  static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
+  static const FeatureParam<UI> a{&kFeature, "a", UI::ONE_D, &uis};
+  static const FeatureParam<UI> b{&kFeature, "b", UI::ONE_D, &uis};
+  static const FeatureParam<UI> c{&kFeature, "c", UI::ONE_D, &uis};
+  static const FeatureParam<UI> d{&kFeature, "d", UI::ONE_D, &uis};
+  static const FeatureParam<UI> e{&kFeature, "e", UI::TWO_D, &uis};
+  static const FeatureParam<UI> f{&kFeature, "f", UI::THREE_D, &uis};
+
+  std::map<std::string, std::string> params;
+  params["a"] = "1d";
+  params["b"] = "2d";
+  params["c"] = "3d";
+  params["d"] = "4d";
+  params["e"] = "";
+  // "f" is not registered
+  AssociateFieldTrialParams(kTrialName, "A", params);
+  scoped_refptr<FieldTrial> trial(
+      CreateFieldTrial(kTrialName, 100, "A", nullptr));
+
+  CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
+                         trial.get());
+
+  EXPECT_EQ(UI::ONE_D, a.Get());
+  EXPECT_EQ(UI::TWO_D, b.Get());
+  EXPECT_EQ(UI::THREE_D, c.Get());
+  EXPECT_EQ(UI::ONE_D, d.Get());    // invalid
+  EXPECT_EQ(UI::TWO_D, e.Get());    // invalid/empty
+  EXPECT_EQ(UI::THREE_D, f.Get());  // not registered
 }
 
 }  // namespace base