field_trial_params_unittest.cc 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/metrics/field_trial_params.h"
  5. #include "base/feature_list.h"
  6. #include "base/metrics/field_trial.h"
  7. #include "base/metrics/field_trial_param_associator.h"
  8. #include "base/test/gtest_util.h"
  9. #include "base/test/scoped_feature_list.h"
  10. #include "base/time/time.h"
  11. #include "testing/gtest/include/gtest/gtest.h"
  12. namespace base {
  13. namespace {
  14. // Call FieldTrialList::FactoryGetFieldTrial().
  15. scoped_refptr<FieldTrial> CreateFieldTrial(
  16. const std::string& trial_name,
  17. int total_probability,
  18. const std::string& default_group_name,
  19. int* default_group_number) {
  20. return FieldTrialList::FactoryGetFieldTrial(
  21. trial_name, total_probability, default_group_name,
  22. FieldTrial::SESSION_RANDOMIZED, default_group_number);
  23. }
  24. } // namespace
  25. class FieldTrialParamsTest : public ::testing::Test {
  26. public:
  27. FieldTrialParamsTest() = default;
  28. FieldTrialParamsTest(const FieldTrialParamsTest&) = delete;
  29. FieldTrialParamsTest& operator=(const FieldTrialParamsTest&) = delete;
  30. ~FieldTrialParamsTest() override {
  31. // Ensure that the maps are cleared between tests, since they are stored as
  32. // process singletons.
  33. FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
  34. }
  35. void CreateFeatureWithTrial(const Feature& feature,
  36. FeatureList::OverrideState override_state,
  37. FieldTrial* trial) {
  38. std::unique_ptr<FeatureList> feature_list(new FeatureList);
  39. feature_list->RegisterFieldTrialOverride(feature.name, override_state,
  40. trial);
  41. scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
  42. }
  43. private:
  44. test::ScopedFeatureList scoped_feature_list_;
  45. };
  46. // Expects a DCHECK if enabled, otherwise compares parameters with EXPECT_EQ.
  47. // std::make_pair is used to evaluate both expressions, so it doesn't matter
  48. // which side causes a DCHECK.
  49. #if DCHECK_IS_ON()
  50. #define EXPECT_DCHECK_OR_EQ(val1, val2) \
  51. EXPECT_DEATH_IF_SUPPORTED(std::make_pair(val1, val2), ".*")
  52. #else
  53. #define EXPECT_DCHECK_OR_EQ(val1, val2) EXPECT_EQ(val1, val2)
  54. #endif
  55. TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams) {
  56. const std::string kTrialName = "AssociateFieldTrialParams";
  57. {
  58. std::map<std::string, std::string> params;
  59. params["a"] = "10";
  60. params["b"] = "test";
  61. ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
  62. }
  63. {
  64. std::map<std::string, std::string> params;
  65. params["a"] = "5";
  66. ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "B", params));
  67. }
  68. FieldTrialList::CreateFieldTrial(kTrialName, "B");
  69. EXPECT_EQ("5", GetFieldTrialParamValue(kTrialName, "a"));
  70. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
  71. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
  72. std::map<std::string, std::string> params;
  73. EXPECT_TRUE(GetFieldTrialParams(kTrialName, &params));
  74. EXPECT_EQ(1U, params.size());
  75. EXPECT_EQ("5", params["a"]);
  76. }
  77. TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_Fail) {
  78. const std::string kTrialName = "AssociateFieldTrialParams_Fail";
  79. const std::string kGroupName = "A";
  80. std::map<std::string, std::string> params;
  81. params["a"] = "10";
  82. ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
  83. params["a"] = "1";
  84. params["b"] = "2";
  85. ASSERT_FALSE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
  86. FieldTrialList::CreateFieldTrial(kTrialName, kGroupName);
  87. EXPECT_EQ("10", GetFieldTrialParamValue(kTrialName, "a"));
  88. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
  89. }
  90. TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_TrialActiveFail) {
  91. const std::string kTrialName = "AssociateFieldTrialParams_TrialActiveFail";
  92. FieldTrialList::CreateFieldTrial(kTrialName, "A");
  93. ASSERT_EQ("A", FieldTrialList::FindFullName(kTrialName));
  94. std::map<std::string, std::string> params;
  95. params["a"] = "10";
  96. EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "B", params));
  97. EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "A", params));
  98. }
  99. TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_DoesntActivateTrial) {
  100. const std::string kTrialName =
  101. "AssociateFieldTrialParams_DoesntActivateTrial";
  102. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  103. scoped_refptr<FieldTrial> trial(
  104. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  105. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  106. std::map<std::string, std::string> params;
  107. params["a"] = "10";
  108. EXPECT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
  109. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  110. }
  111. TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoTrial) {
  112. const std::string kTrialName = "GetFieldTrialParams_NoParams";
  113. std::map<std::string, std::string> params;
  114. EXPECT_FALSE(GetFieldTrialParams(kTrialName, &params));
  115. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
  116. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
  117. }
  118. TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoParams) {
  119. const std::string kTrialName = "GetFieldTrialParams_NoParams";
  120. FieldTrialList::CreateFieldTrial(kTrialName, "A");
  121. std::map<std::string, std::string> params;
  122. EXPECT_FALSE(GetFieldTrialParams(kTrialName, &params));
  123. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
  124. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
  125. }
  126. TEST_F(FieldTrialParamsTest, GetFieldTrialParams_ActivatesTrial) {
  127. const std::string kTrialName = "GetFieldTrialParams_ActivatesTrial";
  128. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  129. scoped_refptr<FieldTrial> trial(
  130. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  131. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  132. std::map<std::string, std::string> params;
  133. EXPECT_FALSE(GetFieldTrialParams(kTrialName, &params));
  134. ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
  135. }
  136. TEST_F(FieldTrialParamsTest, GetFieldTrialParamValue_ActivatesTrial) {
  137. const std::string kTrialName = "GetFieldTrialParamValue_ActivatesTrial";
  138. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  139. scoped_refptr<FieldTrial> trial(
  140. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  141. ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
  142. std::map<std::string, std::string> params;
  143. EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
  144. ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
  145. }
  146. TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature) {
  147. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  148. const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  149. std::map<std::string, std::string> params;
  150. params["x"] = "1";
  151. AssociateFieldTrialParams(kTrialName, "A", params);
  152. scoped_refptr<FieldTrial> trial(
  153. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  154. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  155. trial.get());
  156. std::map<std::string, std::string> actualParams;
  157. EXPECT_TRUE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
  158. EXPECT_EQ(params, actualParams);
  159. }
  160. TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature) {
  161. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  162. const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  163. std::map<std::string, std::string> params;
  164. params["x"] = "1";
  165. AssociateFieldTrialParams(kTrialName, "A", params);
  166. scoped_refptr<FieldTrial> trial(
  167. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  168. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  169. trial.get());
  170. std::map<std::string, std::string> actualParams;
  171. EXPECT_EQ(params["x"], GetFieldTrialParamValueByFeature(kFeature, "x"));
  172. }
  173. TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature_Disable) {
  174. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  175. const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  176. std::map<std::string, std::string> params;
  177. params["x"] = "1";
  178. AssociateFieldTrialParams(kTrialName, "A", params);
  179. scoped_refptr<FieldTrial> trial(
  180. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  181. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
  182. trial.get());
  183. std::map<std::string, std::string> actualParams;
  184. EXPECT_FALSE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
  185. }
  186. TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature_Disable) {
  187. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  188. const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  189. std::map<std::string, std::string> params;
  190. params["x"] = "1";
  191. AssociateFieldTrialParams(kTrialName, "A", params);
  192. scoped_refptr<FieldTrial> trial(
  193. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  194. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
  195. trial.get());
  196. std::map<std::string, std::string> actualParams;
  197. EXPECT_EQ(std::string(), GetFieldTrialParamValueByFeature(kFeature, "x"));
  198. }
  199. TEST_F(FieldTrialParamsTest, FeatureParamString) {
  200. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  201. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  202. static const FeatureParam<std::string> a{&kFeature, "a", "default"};
  203. static const FeatureParam<std::string> b{&kFeature, "b", ""};
  204. static const FeatureParam<std::string> c{&kFeature, "c", "default"};
  205. static const FeatureParam<std::string> d{&kFeature, "d", ""};
  206. static const FeatureParam<std::string> e{&kFeature, "e", "default"};
  207. static const FeatureParam<std::string> f{&kFeature, "f", ""};
  208. std::map<std::string, std::string> params;
  209. params["a"] = "";
  210. params["b"] = "non-default";
  211. params["c"] = "non-default";
  212. params["d"] = "";
  213. // "e" is not registered
  214. // "f" is not registered
  215. AssociateFieldTrialParams(kTrialName, "A", params);
  216. scoped_refptr<FieldTrial> trial(
  217. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  218. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  219. trial.get());
  220. EXPECT_EQ("default", a.Get()); // empty
  221. EXPECT_EQ("non-default", b.Get());
  222. EXPECT_EQ("non-default", c.Get());
  223. EXPECT_EQ("", d.Get()); // empty
  224. EXPECT_EQ("default", e.Get()); // not registered
  225. EXPECT_EQ("", f.Get()); // not registered
  226. }
  227. TEST_F(FieldTrialParamsTest, FeatureParamInt) {
  228. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  229. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  230. static const FeatureParam<int> a{&kFeature, "a", 0};
  231. static const FeatureParam<int> b{&kFeature, "b", 0};
  232. static const FeatureParam<int> c{&kFeature, "c", 0};
  233. static const FeatureParam<int> d{&kFeature, "d", 0};
  234. static const FeatureParam<int> e{&kFeature, "e", 0};
  235. std::map<std::string, std::string> params;
  236. params["a"] = "1";
  237. params["b"] = "1.5";
  238. params["c"] = "foo";
  239. params["d"] = "";
  240. // "e" is not registered
  241. AssociateFieldTrialParams(kTrialName, "A", params);
  242. scoped_refptr<FieldTrial> trial(
  243. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  244. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  245. trial.get());
  246. EXPECT_EQ(1, GetFieldTrialParamByFeatureAsInt(kFeature, "a", 0));
  247. EXPECT_DCHECK_OR_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "b", 0));
  248. EXPECT_DCHECK_OR_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "c", 0));
  249. EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "d", 0)); // empty
  250. EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "e", 0)); // empty
  251. EXPECT_EQ(1, a.Get());
  252. EXPECT_DCHECK_OR_EQ(0, b.Get()); // invalid
  253. EXPECT_DCHECK_OR_EQ(0, c.Get()); // invalid
  254. EXPECT_EQ(0, d.Get()); // empty
  255. EXPECT_EQ(0, e.Get()); // empty
  256. }
  257. TEST_F(FieldTrialParamsTest, FeatureParamDouble) {
  258. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  259. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  260. static const FeatureParam<double> a{&kFeature, "a", 0.0};
  261. static const FeatureParam<double> b{&kFeature, "b", 0.0};
  262. static const FeatureParam<double> c{&kFeature, "c", 0.0};
  263. static const FeatureParam<double> d{&kFeature, "d", 0.0};
  264. static const FeatureParam<double> e{&kFeature, "e", 0.0};
  265. static const FeatureParam<double> f{&kFeature, "f", 0.0};
  266. std::map<std::string, std::string> params;
  267. params["a"] = "1";
  268. params["b"] = "1.5";
  269. params["c"] = "1.0e-10";
  270. params["d"] = "foo";
  271. params["e"] = "";
  272. // "f" is not registered
  273. AssociateFieldTrialParams(kTrialName, "A", params);
  274. scoped_refptr<FieldTrial> trial(
  275. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  276. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  277. trial.get());
  278. EXPECT_EQ(1, GetFieldTrialParamByFeatureAsDouble(kFeature, "a", 0));
  279. EXPECT_EQ(1.5, GetFieldTrialParamByFeatureAsDouble(kFeature, "b", 0));
  280. EXPECT_EQ(1.0e-10, GetFieldTrialParamByFeatureAsDouble(kFeature, "c", 0));
  281. EXPECT_DCHECK_OR_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "d", 0));
  282. EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "e", 0)); // empty
  283. EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "f", 0)); // empty
  284. EXPECT_EQ(1, a.Get());
  285. EXPECT_EQ(1.5, b.Get());
  286. EXPECT_EQ(1.0e-10, c.Get());
  287. EXPECT_DCHECK_OR_EQ(0, d.Get()); // invalid
  288. EXPECT_EQ(0, e.Get()); // empty
  289. EXPECT_EQ(0, f.Get()); // empty
  290. }
  291. TEST_F(FieldTrialParamsTest, FeatureParamBool) {
  292. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  293. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  294. static const FeatureParam<bool> a{&kFeature, "a", false};
  295. static const FeatureParam<bool> b{&kFeature, "b", true};
  296. static const FeatureParam<bool> c{&kFeature, "c", false};
  297. static const FeatureParam<bool> d{&kFeature, "d", true};
  298. static const FeatureParam<bool> e{&kFeature, "e", true};
  299. static const FeatureParam<bool> f{&kFeature, "f", true};
  300. std::map<std::string, std::string> params;
  301. params["a"] = "true";
  302. params["b"] = "false";
  303. params["c"] = "1";
  304. params["d"] = "False";
  305. params["e"] = "";
  306. // "f" is not registered
  307. AssociateFieldTrialParams(kTrialName, "A", params);
  308. scoped_refptr<FieldTrial> trial(
  309. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  310. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  311. trial.get());
  312. EXPECT_TRUE(a.Get());
  313. EXPECT_FALSE(b.Get());
  314. EXPECT_DCHECK_OR_EQ(false, c.Get()); // invalid
  315. EXPECT_DCHECK_OR_EQ(true, d.Get()); // invalid
  316. EXPECT_TRUE(e.Get()); // empty
  317. EXPECT_TRUE(f.Get()); // empty
  318. }
  319. TEST_F(FieldTrialParamsTest, FeatureParamTimeDelta) {
  320. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  321. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  322. static const FeatureParam<base::TimeDelta> a{&kFeature, "a",
  323. base::TimeDelta()};
  324. static const FeatureParam<base::TimeDelta> b{&kFeature, "b",
  325. base::TimeDelta()};
  326. static const FeatureParam<base::TimeDelta> c{&kFeature, "c",
  327. base::TimeDelta()};
  328. static const FeatureParam<base::TimeDelta> d{&kFeature, "d",
  329. base::TimeDelta()};
  330. static const FeatureParam<base::TimeDelta> e{&kFeature, "e",
  331. base::TimeDelta()};
  332. static const FeatureParam<base::TimeDelta> f{&kFeature, "f",
  333. base::TimeDelta()};
  334. std::map<std::string, std::string> params;
  335. params["a"] = "1.5s";
  336. params["b"] = "1h2m";
  337. params["c"] = "1";
  338. params["d"] = "true";
  339. params["e"] = "";
  340. // "f" is not registered
  341. AssociateFieldTrialParams(kTrialName, "A", params);
  342. scoped_refptr<FieldTrial> trial(
  343. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  344. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  345. trial.get());
  346. EXPECT_EQ(a.Get(), base::Seconds(1.5));
  347. EXPECT_EQ(b.Get(), base::Minutes(62));
  348. EXPECT_DCHECK_OR_EQ(c.Get(), base::TimeDelta()); // invalid
  349. EXPECT_DCHECK_OR_EQ(d.Get(), base::TimeDelta()); // invalid
  350. EXPECT_EQ(e.Get(), base::TimeDelta()); // empty
  351. EXPECT_EQ(f.Get(), base::TimeDelta()); // empty
  352. }
  353. enum Hand { ROCK, PAPER, SCISSORS };
  354. TEST_F(FieldTrialParamsTest, FeatureParamEnum) {
  355. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  356. static const FeatureParam<Hand>::Option hands[] = {
  357. {ROCK, "rock"}, {PAPER, "paper"}, {SCISSORS, "scissors"}};
  358. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  359. static const FeatureParam<Hand> a{&kFeature, "a", ROCK, &hands};
  360. static const FeatureParam<Hand> b{&kFeature, "b", ROCK, &hands};
  361. static const FeatureParam<Hand> c{&kFeature, "c", ROCK, &hands};
  362. static const FeatureParam<Hand> d{&kFeature, "d", ROCK, &hands};
  363. static const FeatureParam<Hand> e{&kFeature, "e", PAPER, &hands};
  364. static const FeatureParam<Hand> f{&kFeature, "f", SCISSORS, &hands};
  365. std::map<std::string, std::string> params;
  366. params["a"] = "rock";
  367. params["b"] = "paper";
  368. params["c"] = "scissors";
  369. params["d"] = "lizard";
  370. params["e"] = "";
  371. // "f" is not registered
  372. AssociateFieldTrialParams(kTrialName, "A", params);
  373. scoped_refptr<FieldTrial> trial(
  374. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  375. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  376. trial.get());
  377. EXPECT_EQ(ROCK, a.Get());
  378. EXPECT_EQ(PAPER, b.Get());
  379. EXPECT_EQ(SCISSORS, c.Get());
  380. EXPECT_DCHECK_OR_EQ(ROCK, d.Get()); // invalid
  381. EXPECT_EQ(PAPER, e.Get()); // empty
  382. EXPECT_EQ(SCISSORS, f.Get()); // not registered
  383. }
  384. enum class UI { ONE_D, TWO_D, THREE_D };
  385. TEST_F(FieldTrialParamsTest, FeatureParamEnumClass) {
  386. const std::string kTrialName = "GetFieldTrialParamsByFeature";
  387. static const FeatureParam<UI>::Option uis[] = {
  388. {UI::ONE_D, "1d"}, {UI::TWO_D, "2d"}, {UI::THREE_D, "3d"}};
  389. static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
  390. static const FeatureParam<UI> a{&kFeature, "a", UI::ONE_D, &uis};
  391. static const FeatureParam<UI> b{&kFeature, "b", UI::ONE_D, &uis};
  392. static const FeatureParam<UI> c{&kFeature, "c", UI::ONE_D, &uis};
  393. static const FeatureParam<UI> d{&kFeature, "d", UI::ONE_D, &uis};
  394. static const FeatureParam<UI> e{&kFeature, "e", UI::TWO_D, &uis};
  395. static const FeatureParam<UI> f{&kFeature, "f", UI::THREE_D, &uis};
  396. std::map<std::string, std::string> params;
  397. params["a"] = "1d";
  398. params["b"] = "2d";
  399. params["c"] = "3d";
  400. params["d"] = "4d";
  401. params["e"] = "";
  402. // "f" is not registered
  403. AssociateFieldTrialParams(kTrialName, "A", params);
  404. scoped_refptr<FieldTrial> trial(
  405. CreateFieldTrial(kTrialName, 100, "A", nullptr));
  406. CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
  407. trial.get());
  408. EXPECT_EQ(UI::ONE_D, a.Get());
  409. EXPECT_EQ(UI::TWO_D, b.Get());
  410. EXPECT_EQ(UI::THREE_D, c.Get());
  411. EXPECT_DCHECK_OR_EQ(UI::ONE_D, d.Get()); // invalid
  412. EXPECT_EQ(UI::TWO_D, e.Get()); // empty
  413. EXPECT_EQ(UI::THREE_D, f.Get()); // not registered
  414. }
  415. } // namespace base