components/variations/variations_seed_processor_unittest.cc - platform/external/chromium_org - Git at Google

 // 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"
 #include "components/variations/processed_study.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace chrome_variations {

 namespace {

 // Converts |time| to Study proto format.
 int64 TimeToProtoTime(const base::Time& time) {
   return (time - base::Time::UnixEpoch()).InSeconds();
 }

 // Constants for testing associating command line flags with trial groups.
 const char kFlagStudyName[] = "flag_test_trial";
 const char kFlagGroup1Name[] = "flag_group1";
 const char kFlagGroup2Name[] = "flag_group2";
 const char kNonFlagGroupName[] = "non_flag_group";
 const char kForcingFlag1[] = "flag_test1";
 const char kForcingFlag2[] = "flag_test2";

 const VariationID kExperimentId = 123;

 // Adds an experiment to |study| with the specified |name| and |probability|.
 Study_Experiment* AddExperiment(const std::string& name, int probability,
                                 Study* study) {
   Study_Experiment* experiment = study->add_experiment();
   experiment->set_name(name);
   experiment->set_probability_weight(probability);
   return experiment;
 }

 // Populates |study| with test data used for testing associating command line
 // flags with trials groups. The study will contain three groups, a default
 // group that isn't associated with a flag, and two other groups, both
 // associated with different flags.
 Study CreateStudyWithFlagGroups(int default_group_probability,
                                 int flag_group1_probability,
                                 int flag_group2_probability) {
   DCHECK_GE(default_group_probability, 0);
   DCHECK_GE(flag_group1_probability, 0);
   DCHECK_GE(flag_group2_probability, 0);
   Study study;
   study.set_name(kFlagStudyName);
   study.set_default_experiment_name(kNonFlagGroupName);

   AddExperiment(kNonFlagGroupName, default_group_probability, &study);
   AddExperiment(kFlagGroup1Name, flag_group1_probability, &study)
       ->set_forcing_flag(kForcingFlag1);
   AddExperiment(kFlagGroup2Name, flag_group2_probability, &study)
       ->set_forcing_flag(kForcingFlag2);

   return study;
 }

 // Tests whether a field trial is active (i.e. group() has been called on it).
 bool IsFieldTrialActive(const std::string& trial_name) {
   base::FieldTrial::ActiveGroups active_groups;
   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

 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();
   }

   bool CreateTrialFromStudy(const Study* study) {
     ProcessedStudy processed_study;
     if (processed_study.Init(study, false)) {
       VariationsSeedProcessor().CreateTrialFromStudy(processed_study);
       return true;
     }
     return false;
   }

  private:
   DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
 };

 TEST_F(VariationsSeedProcessorTest, AllowForceGroupAndVariationId) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

   base::FieldTrialList field_trial_list(NULL);

   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);

   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));

   VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
                                         kFlagGroup1Name);
   EXPECT_EQ(kExperimentId, id);
 }

 // Test that the group for kForcingFlag1 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

   base::FieldTrialList field_trial_list(NULL);

   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }

 // Test that the group for kForcingFlag2 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);

   base::FieldTrialList field_trial_list(NULL);

   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(kFlagGroup2Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }

 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);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }

 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);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(kNonFlagGroupName,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }

 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);
   AddExperiment("Default", 0, study1);
   Study* study2 = seed.add_study();
   *study2 = *study1;
   ASSERT_EQ(seed.study(0).name(), seed.study(1).name());

   const base::Time year_ago =
       base::Time::Now() - base::TimeDelta::FromDays(365);

   const base::Version version("20.0.0.0");

   // Check that adding [expired, non-expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     base::FieldTrialList field_trial_list(NULL);
     study1->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                         version, Study_Channel_STABLE,
                                         Study_FormFactor_DESKTOP, "");
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }

   // Check that adding [non-expired, expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     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,
                                         Study_FormFactor_DESKTOP, "");
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 }

 TEST_F(VariationsSeedProcessorTest, ValidateStudy) {
   Study study;
   study.set_default_experiment_name("def");
   AddExperiment("abc", 100, &study);
   Study_Experiment* default_group = AddExperiment("def", 200, &study);

   ProcessedStudy processed_study;
   EXPECT_TRUE(processed_study.Init(&study, false));
   EXPECT_EQ(300, processed_study.total_probability());

   // Min version checks.
   study.mutable_filter()->set_min_version("1.2.3.*");
   EXPECT_TRUE(processed_study.Init(&study, false));
   study.mutable_filter()->set_min_version("1.*.3");
   EXPECT_FALSE(processed_study.Init(&study, false));
   study.mutable_filter()->set_min_version("1.2.3");
   EXPECT_TRUE(processed_study.Init(&study, false));

   // Max version checks.
   study.mutable_filter()->set_max_version("2.3.4.*");
   EXPECT_TRUE(processed_study.Init(&study, false));
   study.mutable_filter()->set_max_version("*.3");
   EXPECT_FALSE(processed_study.Init(&study, false));
   study.mutable_filter()->set_max_version("2.3.4");
   EXPECT_TRUE(processed_study.Init(&study, false));

   study.clear_default_experiment_name();
   EXPECT_FALSE(processed_study.Init(&study, false));

   study.set_default_experiment_name("xyz");
   EXPECT_FALSE(processed_study.Init(&study, false));

   study.set_default_experiment_name("def");
   default_group->clear_name();
   EXPECT_FALSE(processed_study.Init(&study, false));

   default_group->set_name("def");
   EXPECT_TRUE(processed_study.Init(&study, false));
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   EXPECT_FALSE(processed_study.Init(&study, false));
 }

 TEST_F(VariationsSeedProcessorTest, VariationParams) {
   base::FieldTrialList field_trial_list(NULL);

   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);

   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ("y", GetVariationParamValue("Study1", "x"));

   study.set_name("Study2");
   experiment1->set_probability_weight(0);
   experiment2->set_probability_weight(1);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_EQ(std::string(), GetVariationParamValue("Study2", "x"));
 }

 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);
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   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();
   study2->set_name("B");
   study2->set_default_experiment_name("Default");
   AddExperiment("BB", 100, study2);
   AddExperiment("Default", 0, study2);
   study2->set_activation_type(Study_ActivationType_ACTIVATION_AUTO);

   Study* study3 = seed.add_study();
   study3->set_name("C");
   study3->set_default_experiment_name("Default");
   AddExperiment("CC", 100, study3);
   AddExperiment("Default", 0, study3);
   study3->set_activation_type(Study_ActivationType_ACTIVATION_EXPLICIT);

   VariationsSeedProcessor seed_processor;
   seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                       base::Version("20.0.0.0"),
                                       Study_Channel_STABLE,
                                       Study_FormFactor_DESKTOP, "");

   // Non-specified and ACTIVATION_EXPLICIT should not start active, but
   // ACTIVATION_AUTO should.
   EXPECT_FALSE(IsFieldTrialActive("A"));
   EXPECT_TRUE(IsFieldTrialActive("B"));
   EXPECT_FALSE(IsFieldTrialActive("C"));

   EXPECT_EQ("AA", base::FieldTrialList::FindFullName("A"));
   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"));
 }

 TEST_F(VariationsSeedProcessorTest, StartsActiveWithFlag) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

   base::FieldTrialList field_trial_list(NULL);

   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);

   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_TRUE(IsFieldTrialActive(kFlagStudyName));

   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }

 }  // namespace chrome_variations
	// 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"
	#include "components/variations/processed_study.h"
	#include "components/variations/variations_associated_data.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace chrome_variations {

	namespace {

	// Converts \|time\| to Study proto format.
	int64 TimeToProtoTime(const base::Time& time) {
	return (time - base::Time::UnixEpoch()).InSeconds();
	}

	// Constants for testing associating command line flags with trial groups.
	const char kFlagStudyName[] = "flag_test_trial";
	const char kFlagGroup1Name[] = "flag_group1";
	const char kFlagGroup2Name[] = "flag_group2";
	const char kNonFlagGroupName[] = "non_flag_group";
	const char kForcingFlag1[] = "flag_test1";
	const char kForcingFlag2[] = "flag_test2";

	const VariationID kExperimentId = 123;

	// Adds an experiment to \|study\| with the specified \|name\| and \|probability\|.
	Study_Experiment* AddExperiment(const std::string& name, int probability,
	Study* study) {
	Study_Experiment* experiment = study->add_experiment();
	experiment->set_name(name);
	experiment->set_probability_weight(probability);
	return experiment;
	}

	// Populates \|study\| with test data used for testing associating command line
	// flags with trials groups. The study will contain three groups, a default
	// group that isn't associated with a flag, and two other groups, both
	// associated with different flags.
	Study CreateStudyWithFlagGroups(int default_group_probability,
	int flag_group1_probability,
	int flag_group2_probability) {
	DCHECK_GE(default_group_probability, 0);
	DCHECK_GE(flag_group1_probability, 0);
	DCHECK_GE(flag_group2_probability, 0);
	Study study;
	study.set_name(kFlagStudyName);
	study.set_default_experiment_name(kNonFlagGroupName);

	AddExperiment(kNonFlagGroupName, default_group_probability, &study);
	AddExperiment(kFlagGroup1Name, flag_group1_probability, &study)
	->set_forcing_flag(kForcingFlag1);
	AddExperiment(kFlagGroup2Name, flag_group2_probability, &study)
	->set_forcing_flag(kForcingFlag2);

	return study;
	}

	// Tests whether a field trial is active (i.e. group() has been called on it).
	bool IsFieldTrialActive(const std::string& trial_name) {
	base::FieldTrial::ActiveGroups active_groups;
	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

	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();
	}

	bool CreateTrialFromStudy(const Study* study) {
	ProcessedStudy processed_study;
	if (processed_study.Init(study, false)) {
	VariationsSeedProcessor().CreateTrialFromStudy(processed_study);
	return true;
	}
	return false;
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
	};

	TEST_F(VariationsSeedProcessorTest, AllowForceGroupAndVariationId) {
	CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

	base::FieldTrialList field_trial_list(NULL);

	Study study = CreateStudyWithFlagGroups(100, 0, 0);
	study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);

	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(kFlagGroup1Name,
	base::FieldTrialList::FindFullName(kFlagStudyName));

	VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
	kFlagGroup1Name);
	EXPECT_EQ(kExperimentId, id);
	}

	// Test that the group for kForcingFlag1 is forced.
	TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
	CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

	base::FieldTrialList field_trial_list(NULL);

	Study study = CreateStudyWithFlagGroups(100, 0, 0);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(kFlagGroup1Name,
	base::FieldTrialList::FindFullName(kFlagStudyName));
	}

	// Test that the group for kForcingFlag2 is forced.
	TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
	CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);

	base::FieldTrialList field_trial_list(NULL);

	Study study = CreateStudyWithFlagGroups(100, 0, 0);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(kFlagGroup2Name,
	base::FieldTrialList::FindFullName(kFlagStudyName));
	}

	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);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(kFlagGroup1Name,
	base::FieldTrialList::FindFullName(kFlagStudyName));
	}

	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);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(kNonFlagGroupName,
	base::FieldTrialList::FindFullName(kFlagStudyName));
	}

	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);
	AddExperiment("Default", 0, study1);
	Study* study2 = seed.add_study();
	study2 = study1;
	ASSERT_EQ(seed.study(0).name(), seed.study(1).name());

	const base::Time year_ago =
	base::Time::Now() - base::TimeDelta::FromDays(365);

	const base::Version version("20.0.0.0");

	// Check that adding [expired, non-expired] activates the non-expired one.
	ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
	{
	base::FieldTrialList field_trial_list(NULL);
	study1->set_expiry_date(TimeToProtoTime(year_ago));
	seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
	version, Study_Channel_STABLE,
	Study_FormFactor_DESKTOP, "");
	EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
	}

	// Check that adding [non-expired, expired] activates the non-expired one.
	ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
	{
	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,
	Study_FormFactor_DESKTOP, "");
	EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
	}
	}

	TEST_F(VariationsSeedProcessorTest, ValidateStudy) {
	Study study;
	study.set_default_experiment_name("def");
	AddExperiment("abc", 100, &study);
	Study_Experiment* default_group = AddExperiment("def", 200, &study);

	ProcessedStudy processed_study;
	EXPECT_TRUE(processed_study.Init(&study, false));
	EXPECT_EQ(300, processed_study.total_probability());

	// Min version checks.
	study.mutable_filter()->set_min_version("1.2.3.*");
	EXPECT_TRUE(processed_study.Init(&study, false));
	study.mutable_filter()->set_min_version("1.*.3");
	EXPECT_FALSE(processed_study.Init(&study, false));
	study.mutable_filter()->set_min_version("1.2.3");
	EXPECT_TRUE(processed_study.Init(&study, false));

	// Max version checks.
	study.mutable_filter()->set_max_version("2.3.4.*");
	EXPECT_TRUE(processed_study.Init(&study, false));
	study.mutable_filter()->set_max_version("*.3");
	EXPECT_FALSE(processed_study.Init(&study, false));
	study.mutable_filter()->set_max_version("2.3.4");
	EXPECT_TRUE(processed_study.Init(&study, false));

	study.clear_default_experiment_name();
	EXPECT_FALSE(processed_study.Init(&study, false));

	study.set_default_experiment_name("xyz");
	EXPECT_FALSE(processed_study.Init(&study, false));

	study.set_default_experiment_name("def");
	default_group->clear_name();
	EXPECT_FALSE(processed_study.Init(&study, false));

	default_group->set_name("def");
	EXPECT_TRUE(processed_study.Init(&study, false));
	Study_Experiment* repeated_group = study.add_experiment();
	repeated_group->set_name("abc");
	repeated_group->set_probability_weight(1);
	EXPECT_FALSE(processed_study.Init(&study, false));
	}

	TEST_F(VariationsSeedProcessorTest, VariationParams) {
	base::FieldTrialList field_trial_list(NULL);

	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);

	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ("y", GetVariationParamValue("Study1", "x"));

	study.set_name("Study2");
	experiment1->set_probability_weight(0);
	experiment2->set_probability_weight(1);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_EQ(std::string(), GetVariationParamValue("Study2", "x"));
	}

	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);
	EXPECT_TRUE(CreateTrialFromStudy(&study));
	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();
	study2->set_name("B");
	study2->set_default_experiment_name("Default");
	AddExperiment("BB", 100, study2);
	AddExperiment("Default", 0, study2);
	study2->set_activation_type(Study_ActivationType_ACTIVATION_AUTO);

	Study* study3 = seed.add_study();
	study3->set_name("C");
	study3->set_default_experiment_name("Default");
	AddExperiment("CC", 100, study3);
	AddExperiment("Default", 0, study3);
	study3->set_activation_type(Study_ActivationType_ACTIVATION_EXPLICIT);

	VariationsSeedProcessor seed_processor;
	seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
	base::Version("20.0.0.0"),
	Study_Channel_STABLE,
	Study_FormFactor_DESKTOP, "");

	// Non-specified and ACTIVATION_EXPLICIT should not start active, but
	// ACTIVATION_AUTO should.
	EXPECT_FALSE(IsFieldTrialActive("A"));
	EXPECT_TRUE(IsFieldTrialActive("B"));
	EXPECT_FALSE(IsFieldTrialActive("C"));

	EXPECT_EQ("AA", base::FieldTrialList::FindFullName("A"));
	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"));
	}

	TEST_F(VariationsSeedProcessorTest, StartsActiveWithFlag) {
	CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);

	base::FieldTrialList field_trial_list(NULL);

	Study study = CreateStudyWithFlagGroups(100, 0, 0);
	study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);

	EXPECT_TRUE(CreateTrialFromStudy(&study));
	EXPECT_TRUE(IsFieldTrialActive(kFlagStudyName));

	EXPECT_EQ(kFlagGroup1Name,
	base::FieldTrialList::FindFullName(kFlagStudyName));
	}

	} // namespace chrome_variations