Support variation params for forcing_flag groups.

components/variations/variations_seed_processor_unittest.cc

 // Copyright 2013 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 "components/variations/variations_seed_processor.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
@@ skipping 55 matching lines @@
   base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
   for (size_t i = 0; i < active_groups.size(); ++i) {
     if (active_groups[i].trial_name == trial_name)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
-TEST(VariationsSeedProcessorTest, CheckStudyChannel) {
+class VariationsSeedProcessorTest : public ::testing::Test {
+ public:
+  VariationsSeedProcessorTest() {
+  }
+
+  virtual ~VariationsSeedProcessorTest() {
+    // Ensure that the maps are cleared between tests, since they are stored as
+    // process singletons.
+    testing::ClearAllVariationIDs();
+    testing::ClearAllVariationParams();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
+};
+
+TEST_F(VariationsSeedProcessorTest, CheckStudyChannel) {
   VariationsSeedProcessor seed_processor;
 
   const Study_Channel channels[] = {
     Study_Channel_CANARY,
     Study_Channel_DEV,
     Study_Channel_BETA,
     Study_Channel_STABLE,
   };
   bool channel_added[arraysize(channels)] = { 0 };
 
@@ skipping 25 matching lines @@
     }
 
     if (i < arraysize(channels)) {
       const int index = arraysize(channels) - i - 1;
       filter.add_channel(channels[index]);
       channel_added[index] = true;
     }
   }
 }
 
-TEST(VariationsSeedProcessorTest, CheckStudyLocale) {
+TEST_F(VariationsSeedProcessorTest, CheckStudyLocale) {
   VariationsSeedProcessor seed_processor;
 
   struct {
     const char* filter_locales;
     bool en_us_result;
     bool en_ca_result;
     bool fr_result;
   } test_cases[] = {
     {"en-US", true, false, false},
     {"en-US,en-CA,fr", true, true, true},
@@ skipping 12 matching lines @@
       filter.add_locale(filter_locales[j]);
     EXPECT_EQ(test_cases[i].en_us_result,
               seed_processor.CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               seed_processor.CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
               seed_processor.CheckStudyLocale(filter, "fr"));
   }
 }
 
-TEST(VariationsSeedProcessorTest, CheckStudyPlatform) {
+TEST_F(VariationsSeedProcessorTest, CheckStudyPlatform) {
   VariationsSeedProcessor seed_processor;
 
   const Study_Platform platforms[] = {
     Study_Platform_PLATFORM_WINDOWS,
     Study_Platform_PLATFORM_MAC,
     Study_Platform_PLATFORM_LINUX,
     Study_Platform_PLATFORM_CHROMEOS,
     Study_Platform_PLATFORM_ANDROID,
     Study_Platform_PLATFORM_IOS,
   };
@@ skipping 31 matching lines @@
     }
 
     if (i < arraysize(platforms)) {
       const int index = arraysize(platforms) - i - 1;
       filter.add_platform(platforms[index]);
       platform_added[index] = true;
     }
   }
 }
 
-TEST(VariationsSeedProcessorTest, CheckStudyStartDate) {
+TEST_F(VariationsSeedProcessorTest, CheckStudyStartDate) {
   VariationsSeedProcessor seed_processor;
 
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time start_date;
     bool expected_result;
   } start_test_cases[] = {
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study_Filter filter;
 
   // Start date not set should result in true.
   EXPECT_TRUE(seed_processor.CheckStudyStartDate(filter, now));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(start_test_cases); ++i) {
     filter.set_start_date(TimeToProtoTime(start_test_cases[i].start_date));
     const bool result = seed_processor.CheckStudyStartDate(filter, now);
     EXPECT_EQ(start_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
-TEST(VariationsSeedProcessorTest, CheckStudyVersion) {
+TEST_F(VariationsSeedProcessorTest, CheckStudyVersion) {
   VariationsSeedProcessor seed_processor;
 
   const struct {
     const char* min_version;
     const char* version;
     bool expected_result;
   } min_test_cases[] = {
     { "1.2.2", "1.2.3", true },
     { "1.2.3", "1.2.3", true },
     { "1.2.4", "1.2.3", false },
@@ skipping 71 matching lines @@
         const bool result =
             seed_processor.CheckStudyVersion(
                 filter, Version(max_test_cases[j].version));
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
     }
   }
 }
 
 // Test that the group for kForcingFlag1 is forced.
-TEST(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
+TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   VariationsSeedProcessor().CreateTrialFromStudy(study, false);
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 // Test that the group for kForcingFlag2 is forced.
-TEST(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
+TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   VariationsSeedProcessor().CreateTrialFromStudy(study, false);
 
   EXPECT_EQ(kFlagGroup2Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
-TEST(VariationsSeedProcessorTest, ForceGroup_ChooseFirstGroupWithFlag) {
+TEST_F(VariationsSeedProcessorTest, ForceGroup_ChooseFirstGroupWithFlag) {
   // Add the flag to the command line arguments so the flag group is forced.
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   VariationsSeedProcessor().CreateTrialFromStudy(study, false);
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
-TEST(VariationsSeedProcessorTest, ForceGroup_DontChooseGroupWithFlag) {
+TEST_F(VariationsSeedProcessorTest, ForceGroup_DontChooseGroupWithFlag) {
   base::FieldTrialList field_trial_list(NULL);
 
   // The two flag groups are given high probability, which would normally make
   // them very likely to be chosen. They won't be chosen since flag groups are
   // never chosen when their flag isn't present.
   Study study = CreateStudyWithFlagGroups(1, 999, 999);
   VariationsSeedProcessor().CreateTrialFromStudy(study, false);
   EXPECT_EQ(kNonFlagGroupName,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
-TEST(VariationsSeedProcessorTest, IsStudyExpired) {
+TEST_F(VariationsSeedProcessorTest, IsStudyExpired) {
   VariationsSeedProcessor seed_processor;
 
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time expiry_date;
     bool expected_result;
   } expiry_test_cases[] = {
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study study;
 
   // Expiry date not set should result in false.
   EXPECT_FALSE(seed_processor.IsStudyExpired(study, now));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(expiry_test_cases); ++i) {
     study.set_expiry_date(TimeToProtoTime(expiry_test_cases[i].expiry_date));
     const bool result = seed_processor.IsStudyExpired(study, now);
     EXPECT_EQ(expiry_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
-TEST(VariationsSeedProcessorTest, NonExpiredStudyPrioritizedOverExpiredStudy) {
+TEST_F(VariationsSeedProcessorTest,
+       NonExpiredStudyPrioritizedOverExpiredStudy) {
   VariationsSeedProcessor seed_processor;
 
   const std::string kTrialName = "A";
   const std::string kGroup1Name = "Group1";
 
   VariationsSeed seed;
   Study* study1 = seed.add_study();
   study1->set_name(kTrialName);
   study1->set_default_experiment_name("Default");
   AddExperiment(kGroup1Name, 100, study1);
@@ skipping 22 matching lines @@
   {
     base::FieldTrialList field_trial_list(NULL);
     study1->clear_expiry_date();
     study2->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                         version, Study_Channel_STABLE);
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 }
 
-TEST(VariationsSeedProcessorTest, ValidateStudy) {
+TEST_F(VariationsSeedProcessorTest, ValidateStudy) {
   VariationsSeedProcessor seed_processor;
 
   Study study;
   study.set_default_experiment_name("def");
   AddExperiment("abc", 100, &study);
   Study_Experiment* default_group = AddExperiment("def", 200, &study);
 
   base::FieldTrial::Probability total_probability = 0;
   bool valid = seed_processor.ValidateStudyAndComputeTotalProbability(
       study, &total_probability);
@@ skipping 49 matching lines @@
       &total_probability);
   ASSERT_TRUE(valid);
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   valid = seed_processor.ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 }
 
-TEST(VariationsSeedProcessorTest, VariationParams) {
+TEST_F(VariationsSeedProcessorTest, VariationParams) {
   base::FieldTrialList field_trial_list(NULL);
   VariationsSeedProcessor seed_processor;
 
   Study study;
   study.set_name("Study1");
   study.set_default_experiment_name("B");
 
   Study_Experiment* experiment1 = AddExperiment("A", 1, &study);
   Study_Experiment_Param* param = experiment1->add_param();
   param->set_name("x");
   param->set_value("y");
 
   Study_Experiment* experiment2 = AddExperiment("B", 0, &study);
 
   seed_processor.CreateTrialFromStudy(study, false);
   EXPECT_EQ("y", GetVariationParamValue("Study1", "x"));
 
   study.set_name("Study2");
   experiment1->set_probability_weight(0);
   experiment2->set_probability_weight(1);
   seed_processor.CreateTrialFromStudy(study, false);
   EXPECT_EQ(std::string(), GetVariationParamValue("Study2", "x"));
 }
 
-TEST(VariationsSeedProcessorTest, StartsActive) {
+TEST_F(VariationsSeedProcessorTest, VariationParamsWithForcingFlag) {
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  ASSERT_EQ(kForcingFlag1, study.experiment(1).forcing_flag());
+  Study_Experiment_Param* param = study.mutable_experiment(1)->add_param();
+  param->set_name("x");
+  param->set_value("y");
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
+  base::FieldTrialList field_trial_list(NULL);
+  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  EXPECT_EQ(kFlagGroup1Name, base::FieldTrialList::FindFullName(study.name()));
+  EXPECT_EQ("y", GetVariationParamValue(study.name(), "x"));
+}
+
+TEST_F(VariationsSeedProcessorTest, StartsActive) {
   base::FieldTrialList field_trial_list(NULL);
 
   VariationsSeed seed;
   Study* study1 = seed.add_study();
   study1->set_name("A");
   study1->set_default_experiment_name("Default");
   AddExperiment("AA", 100, study1);
   AddExperiment("Default", 0, study1);
 
   Study* study2 = seed.add_study();
@@ skipping 25 matching lines @@
   EXPECT_EQ("BB", base::FieldTrialList::FindFullName("B"));
   EXPECT_EQ("CC", base::FieldTrialList::FindFullName("C"));
 
   // Now, all studies should be active.
   EXPECT_TRUE(IsFieldTrialActive("A"));
   EXPECT_TRUE(IsFieldTrialActive("B"));
   EXPECT_TRUE(IsFieldTrialActive("C"));
 }
 
 }  // namespace chrome_variations