OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/variations/variations_associated_data.h" | 5 #include "base/metrics/field_trial_params.h" |
6 | 6 |
7 #include "base/feature_list.h" | 7 #include "base/feature_list.h" |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/metrics/field_trial.h" | 9 #include "base/metrics/field_trial.h" |
| 10 #include "base/metrics/field_trial_param_associator.h" |
10 #include "base/test/scoped_feature_list.h" | 11 #include "base/test/scoped_feature_list.h" |
11 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
12 | 13 |
13 namespace variations { | 14 namespace base { |
14 | 15 |
15 namespace { | 16 namespace { |
16 | 17 |
17 const VariationID TEST_VALUE_A = 3300200; | |
18 const VariationID TEST_VALUE_B = 3300201; | |
19 | |
20 // Convenience helper to retrieve the variations::VariationID for a FieldTrial. | |
21 // Note that this will do the group assignment in |trial| if not already done. | |
22 VariationID GetIDForTrial(IDCollectionKey key, base::FieldTrial* trial) { | |
23 return GetGoogleVariationID(key, trial->trial_name(), trial->group_name()); | |
24 } | |
25 | |
26 // Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date. | 18 // Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date. |
27 scoped_refptr<base::FieldTrial> CreateFieldTrial( | 19 scoped_refptr<FieldTrial> CreateFieldTrial( |
28 const std::string& trial_name, | 20 const std::string& trial_name, |
29 int total_probability, | 21 int total_probability, |
30 const std::string& default_group_name, | 22 const std::string& default_group_name, |
31 int* default_group_number) { | 23 int* default_group_number) { |
32 return base::FieldTrialList::FactoryGetFieldTrial( | 24 return FieldTrialList::FactoryGetFieldTrial( |
33 trial_name, total_probability, default_group_name, | 25 trial_name, total_probability, default_group_name, |
34 base::FieldTrialList::kNoExpirationYear, 1, 1, | 26 FieldTrialList::kNoExpirationYear, 1, 1, FieldTrial::SESSION_RANDOMIZED, |
35 base::FieldTrial::SESSION_RANDOMIZED, default_group_number); | 27 default_group_number); |
36 } | 28 } |
37 | 29 |
38 } // namespace | 30 } // namespace |
39 | 31 |
40 class VariationsAssociatedDataTest : public ::testing::Test { | 32 class FieldTrialParamsTest : public ::testing::Test { |
41 public: | 33 public: |
42 VariationsAssociatedDataTest() : field_trial_list_(NULL) { | 34 FieldTrialParamsTest() : field_trial_list_(nullptr) {} |
43 } | 35 |
44 | 36 ~FieldTrialParamsTest() override { |
45 ~VariationsAssociatedDataTest() override { | |
46 // Ensure that the maps are cleared between tests, since they are stored as | 37 // Ensure that the maps are cleared between tests, since they are stored as |
47 // process singletons. | 38 // process singletons. |
48 testing::ClearAllVariationIDs(); | 39 FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting(); |
49 testing::ClearAllVariationParams(); | 40 } |
50 } | 41 |
51 | 42 void CreateFeatureWithTrial(const Feature& feature, |
52 void CreateFeatureWithTrial(const base::Feature& feature, | 43 FeatureList::OverrideState override_state, |
53 base::FeatureList::OverrideState override_state, | 44 FieldTrial* trial) { |
54 base::FieldTrial* trial) { | 45 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
55 std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); | |
56 feature_list->RegisterFieldTrialOverride(feature.name, override_state, | 46 feature_list->RegisterFieldTrialOverride(feature.name, override_state, |
57 trial); | 47 trial); |
58 scoped_feature_list_.InitWithFeatureList(std::move(feature_list)); | 48 scoped_feature_list_.InitWithFeatureList(std::move(feature_list)); |
59 } | 49 } |
60 | 50 |
61 private: | 51 private: |
62 base::FieldTrialList field_trial_list_; | 52 FieldTrialList field_trial_list_; |
63 base::test::ScopedFeatureList scoped_feature_list_; | 53 test::ScopedFeatureList scoped_feature_list_; |
64 | 54 |
65 DISALLOW_COPY_AND_ASSIGN(VariationsAssociatedDataTest); | 55 DISALLOW_COPY_AND_ASSIGN(FieldTrialParamsTest); |
66 }; | 56 }; |
67 | 57 |
68 // Test that if the trial is immediately disabled, GetGoogleVariationID just | 58 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams) { |
69 // returns the empty ID. | 59 const std::string kTrialName = "AssociateFieldTrialParams"; |
70 TEST_F(VariationsAssociatedDataTest, DisableImmediately) { | |
71 int default_group_number = -1; | |
72 scoped_refptr<base::FieldTrial> trial( | |
73 CreateFieldTrial("trial", 100, "default", &default_group_number)); | |
74 | |
75 ASSERT_EQ(default_group_number, trial->group()); | |
76 ASSERT_EQ(EMPTY_ID, GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial.get())); | |
77 } | |
78 | |
79 // Test that successfully associating the FieldTrial with some ID, and then | |
80 // disabling the FieldTrial actually makes GetGoogleVariationID correctly | |
81 // return the empty ID. | |
82 TEST_F(VariationsAssociatedDataTest, DisableAfterInitialization) { | |
83 const std::string default_name = "default"; | |
84 const std::string non_default_name = "non_default"; | |
85 | |
86 scoped_refptr<base::FieldTrial> trial( | |
87 CreateFieldTrial("trial", 100, default_name, NULL)); | |
88 | |
89 trial->AppendGroup(non_default_name, 100); | |
90 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial->trial_name(), | |
91 default_name, TEST_VALUE_A); | |
92 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial->trial_name(), | |
93 non_default_name, TEST_VALUE_B); | |
94 trial->Disable(); | |
95 ASSERT_EQ(default_name, trial->group_name()); | |
96 ASSERT_EQ(TEST_VALUE_A, GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial.get())); | |
97 } | |
98 | |
99 // Test various successful association cases. | |
100 TEST_F(VariationsAssociatedDataTest, AssociateGoogleVariationID) { | |
101 const std::string default_name1 = "default"; | |
102 scoped_refptr<base::FieldTrial> trial_true( | |
103 CreateFieldTrial("d1", 10, default_name1, NULL)); | |
104 const std::string winner = "TheWinner"; | |
105 int winner_group = trial_true->AppendGroup(winner, 10); | |
106 | |
107 // Set GoogleVariationIDs so we can verify that they were chosen correctly. | |
108 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(), | |
109 default_name1, TEST_VALUE_A); | |
110 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(), | |
111 winner, TEST_VALUE_B); | |
112 | |
113 EXPECT_EQ(winner_group, trial_true->group()); | |
114 EXPECT_EQ(winner, trial_true->group_name()); | |
115 EXPECT_EQ(TEST_VALUE_B, | |
116 GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get())); | |
117 | |
118 const std::string default_name2 = "default2"; | |
119 scoped_refptr<base::FieldTrial> trial_false( | |
120 CreateFieldTrial("d2", 10, default_name2, NULL)); | |
121 const std::string loser = "ALoser"; | |
122 const int loser_group = trial_false->AppendGroup(loser, 0); | |
123 | |
124 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_false->trial_name(), | |
125 default_name2, TEST_VALUE_A); | |
126 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_false->trial_name(), | |
127 loser, TEST_VALUE_B); | |
128 | |
129 EXPECT_NE(loser_group, trial_false->group()); | |
130 EXPECT_EQ(TEST_VALUE_A, | |
131 GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_false.get())); | |
132 } | |
133 | |
134 // Test that not associating a FieldTrial with any IDs ensure that the empty ID | |
135 // will be returned. | |
136 TEST_F(VariationsAssociatedDataTest, NoAssociation) { | |
137 const std::string default_name = "default"; | |
138 scoped_refptr<base::FieldTrial> no_id_trial( | |
139 CreateFieldTrial("d3", 10, default_name, NULL)); | |
140 | |
141 const std::string winner = "TheWinner"; | |
142 const int winner_group = no_id_trial->AppendGroup(winner, 10); | |
143 | |
144 // Ensure that despite the fact that a normal winner is elected, it does not | |
145 // have a valid VariationID associated with it. | |
146 EXPECT_EQ(winner_group, no_id_trial->group()); | |
147 EXPECT_EQ(winner, no_id_trial->group_name()); | |
148 EXPECT_EQ(EMPTY_ID, GetIDForTrial(GOOGLE_WEB_PROPERTIES, no_id_trial.get())); | |
149 } | |
150 | |
151 // Ensure that the AssociateGoogleVariationIDForce works as expected. | |
152 TEST_F(VariationsAssociatedDataTest, ForceAssociation) { | |
153 EXPECT_EQ(EMPTY_ID, | |
154 GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group")); | |
155 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group", | |
156 TEST_VALUE_A); | |
157 EXPECT_EQ(TEST_VALUE_A, | |
158 GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group")); | |
159 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group", | |
160 TEST_VALUE_B); | |
161 EXPECT_EQ(TEST_VALUE_A, | |
162 GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group")); | |
163 AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES, "trial", "group", | |
164 TEST_VALUE_B); | |
165 EXPECT_EQ(TEST_VALUE_B, | |
166 GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group")); | |
167 } | |
168 | |
169 // Ensure that two collections can coexist without affecting each other. | |
170 TEST_F(VariationsAssociatedDataTest, CollectionsCoexist) { | |
171 const std::string default_name = "default"; | |
172 int default_group_number = -1; | |
173 scoped_refptr<base::FieldTrial> trial_true( | |
174 CreateFieldTrial("d1", 10, default_name, &default_group_number)); | |
175 ASSERT_EQ(default_group_number, trial_true->group()); | |
176 ASSERT_EQ(default_name, trial_true->group_name()); | |
177 | |
178 EXPECT_EQ(EMPTY_ID, | |
179 GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get())); | |
180 EXPECT_EQ(EMPTY_ID, | |
181 GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get())); | |
182 EXPECT_EQ(EMPTY_ID, | |
183 GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get())); | |
184 | |
185 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(), | |
186 default_name, TEST_VALUE_A); | |
187 EXPECT_EQ(TEST_VALUE_A, | |
188 GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get())); | |
189 EXPECT_EQ(EMPTY_ID, | |
190 GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get())); | |
191 | |
192 AssociateGoogleVariationID(CHROME_SYNC_SERVICE, trial_true->trial_name(), | |
193 default_name, TEST_VALUE_A); | |
194 EXPECT_EQ(TEST_VALUE_A, | |
195 GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get())); | |
196 EXPECT_EQ(TEST_VALUE_A, | |
197 GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get())); | |
198 | |
199 trial_true = CreateFieldTrial("d2", 10, default_name, &default_group_number); | |
200 ASSERT_EQ(default_group_number, trial_true->group()); | |
201 ASSERT_EQ(default_name, trial_true->group_name()); | |
202 | |
203 AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES_TRIGGER, | |
204 trial_true->trial_name(), default_name, | |
205 TEST_VALUE_A); | |
206 EXPECT_EQ(TEST_VALUE_A, | |
207 GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get())); | |
208 EXPECT_EQ(EMPTY_ID, | |
209 GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get())); | |
210 | |
211 AssociateGoogleVariationID(CHROME_SYNC_SERVICE, trial_true->trial_name(), | |
212 default_name, TEST_VALUE_A); | |
213 EXPECT_EQ(TEST_VALUE_A, | |
214 GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get())); | |
215 EXPECT_EQ(TEST_VALUE_A, | |
216 GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get())); | |
217 } | |
218 | |
219 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams) { | |
220 const std::string kTrialName = "AssociateVariationParams"; | |
221 | 60 |
222 { | 61 { |
223 std::map<std::string, std::string> params; | 62 std::map<std::string, std::string> params; |
224 params["a"] = "10"; | 63 params["a"] = "10"; |
225 params["b"] = "test"; | 64 params["b"] = "test"; |
226 ASSERT_TRUE(AssociateVariationParams(kTrialName, "A", params)); | 65 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params)); |
227 } | 66 } |
228 { | 67 { |
229 std::map<std::string, std::string> params; | 68 std::map<std::string, std::string> params; |
230 params["a"] = "5"; | 69 params["a"] = "5"; |
231 ASSERT_TRUE(AssociateVariationParams(kTrialName, "B", params)); | 70 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "B", params)); |
232 } | 71 } |
233 | 72 |
234 base::FieldTrialList::CreateFieldTrial(kTrialName, "B"); | 73 FieldTrialList::CreateFieldTrial(kTrialName, "B"); |
235 EXPECT_EQ("5", GetVariationParamValue(kTrialName, "a")); | 74 EXPECT_EQ("5", GetFieldTrialParamValue(kTrialName, "a")); |
236 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "b")); | 75 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b")); |
237 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x")); | 76 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x")); |
238 | 77 |
239 std::map<std::string, std::string> params; | 78 std::map<std::string, std::string> params; |
240 EXPECT_TRUE(GetVariationParams(kTrialName, ¶ms)); | 79 EXPECT_TRUE(GetFieldTrialParams(kTrialName, ¶ms)); |
241 EXPECT_EQ(1U, params.size()); | 80 EXPECT_EQ(1U, params.size()); |
242 EXPECT_EQ("5", params["a"]); | 81 EXPECT_EQ("5", params["a"]); |
243 } | 82 } |
244 | 83 |
245 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams_Fail) { | 84 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_Fail) { |
246 const std::string kTrialName = "AssociateVariationParams_Fail"; | 85 const std::string kTrialName = "AssociateFieldTrialParams_Fail"; |
247 const std::string kGroupName = "A"; | 86 const std::string kGroupName = "A"; |
248 | 87 |
249 std::map<std::string, std::string> params; | 88 std::map<std::string, std::string> params; |
250 params["a"] = "10"; | 89 params["a"] = "10"; |
251 ASSERT_TRUE(AssociateVariationParams(kTrialName, kGroupName, params)); | 90 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, kGroupName, params)); |
252 params["a"] = "1"; | 91 params["a"] = "1"; |
253 params["b"] = "2"; | 92 params["b"] = "2"; |
254 ASSERT_FALSE(AssociateVariationParams(kTrialName, kGroupName, params)); | 93 ASSERT_FALSE(AssociateFieldTrialParams(kTrialName, kGroupName, params)); |
255 | 94 |
256 base::FieldTrialList::CreateFieldTrial(kTrialName, kGroupName); | 95 FieldTrialList::CreateFieldTrial(kTrialName, kGroupName); |
257 EXPECT_EQ("10", GetVariationParamValue(kTrialName, "a")); | 96 EXPECT_EQ("10", GetFieldTrialParamValue(kTrialName, "a")); |
258 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "b")); | 97 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b")); |
259 } | 98 } |
260 | 99 |
261 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams_TrialActiveFail) { | 100 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_TrialActiveFail) { |
262 const std::string kTrialName = "AssociateVariationParams_TrialActiveFail"; | 101 const std::string kTrialName = "AssociateFieldTrialParams_TrialActiveFail"; |
263 base::FieldTrialList::CreateFieldTrial(kTrialName, "A"); | 102 FieldTrialList::CreateFieldTrial(kTrialName, "A"); |
264 ASSERT_EQ("A", base::FieldTrialList::FindFullName(kTrialName)); | 103 ASSERT_EQ("A", FieldTrialList::FindFullName(kTrialName)); |
265 | 104 |
266 std::map<std::string, std::string> params; | 105 std::map<std::string, std::string> params; |
267 params["a"] = "10"; | 106 params["a"] = "10"; |
268 EXPECT_FALSE(AssociateVariationParams(kTrialName, "B", params)); | 107 EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "B", params)); |
269 EXPECT_FALSE(AssociateVariationParams(kTrialName, "A", params)); | 108 EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "A", params)); |
270 } | 109 } |
271 | 110 |
272 TEST_F(VariationsAssociatedDataTest, | 111 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_DoesntActivateTrial) { |
273 AssociateVariationParams_DoesntActivateTrial) { | 112 const std::string kTrialName = |
274 const std::string kTrialName = "AssociateVariationParams_DoesntActivateTrial"; | 113 "AssociateFieldTrialParams_DoesntActivateTrial"; |
275 | 114 |
276 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 115 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
277 scoped_refptr<base::FieldTrial> trial( | 116 scoped_refptr<FieldTrial> trial( |
278 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 117 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
279 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 118 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
280 | 119 |
281 std::map<std::string, std::string> params; | 120 std::map<std::string, std::string> params; |
282 params["a"] = "10"; | 121 params["a"] = "10"; |
283 EXPECT_TRUE(AssociateVariationParams(kTrialName, "A", params)); | 122 EXPECT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params)); |
284 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 123 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
285 } | 124 } |
286 | 125 |
287 TEST_F(VariationsAssociatedDataTest, GetVariationParams_NoTrial) { | 126 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoTrial) { |
288 const std::string kTrialName = "GetVariationParams_NoParams"; | 127 const std::string kTrialName = "GetFieldTrialParams_NoParams"; |
289 | 128 |
290 std::map<std::string, std::string> params; | 129 std::map<std::string, std::string> params; |
291 EXPECT_FALSE(GetVariationParams(kTrialName, ¶ms)); | 130 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms)); |
292 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x")); | 131 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x")); |
293 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "y")); | 132 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y")); |
294 } | 133 } |
295 | 134 |
296 TEST_F(VariationsAssociatedDataTest, GetVariationParams_NoParams) { | 135 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoParams) { |
297 const std::string kTrialName = "GetVariationParams_NoParams"; | 136 const std::string kTrialName = "GetFieldTrialParams_NoParams"; |
298 | 137 |
299 base::FieldTrialList::CreateFieldTrial(kTrialName, "A"); | 138 FieldTrialList::CreateFieldTrial(kTrialName, "A"); |
300 | 139 |
301 std::map<std::string, std::string> params; | 140 std::map<std::string, std::string> params; |
302 EXPECT_FALSE(GetVariationParams(kTrialName, ¶ms)); | 141 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms)); |
303 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x")); | 142 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x")); |
304 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "y")); | 143 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y")); |
305 } | 144 } |
306 | 145 |
307 TEST_F(VariationsAssociatedDataTest, GetVariationParams_ActivatesTrial) { | 146 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_ActivatesTrial) { |
308 const std::string kTrialName = "GetVariationParams_ActivatesTrial"; | 147 const std::string kTrialName = "GetFieldTrialParams_ActivatesTrial"; |
309 | 148 |
310 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 149 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
311 scoped_refptr<base::FieldTrial> trial( | 150 scoped_refptr<FieldTrial> trial( |
312 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 151 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
313 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 152 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
314 | 153 |
315 std::map<std::string, std::string> params; | 154 std::map<std::string, std::string> params; |
316 EXPECT_FALSE(GetVariationParams(kTrialName, ¶ms)); | 155 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms)); |
317 ASSERT_TRUE(base::FieldTrialList::IsTrialActive(kTrialName)); | 156 ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); |
318 } | 157 } |
319 | 158 |
320 TEST_F(VariationsAssociatedDataTest, GetVariationParamValue_ActivatesTrial) { | 159 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValue_ActivatesTrial) { |
321 const std::string kTrialName = "GetVariationParamValue_ActivatesTrial"; | 160 const std::string kTrialName = "GetFieldTrialParamValue_ActivatesTrial"; |
322 | 161 |
323 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 162 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
324 scoped_refptr<base::FieldTrial> trial( | 163 scoped_refptr<FieldTrial> trial( |
325 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 164 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
326 ASSERT_FALSE(base::FieldTrialList::IsTrialActive(kTrialName)); | 165 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
327 | 166 |
328 std::map<std::string, std::string> params; | 167 std::map<std::string, std::string> params; |
329 EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x")); | 168 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x")); |
330 ASSERT_TRUE(base::FieldTrialList::IsTrialActive(kTrialName)); | 169 ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); |
331 } | 170 } |
332 | 171 |
333 TEST_F(VariationsAssociatedDataTest, GetVariationParamsByFeature) { | 172 TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature) { |
334 const std::string kTrialName = "GetVariationParamsByFeature"; | 173 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
335 const base::Feature kFeature{"TestFeature", | 174 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
336 base::FEATURE_DISABLED_BY_DEFAULT}; | 175 |
337 | 176 std::map<std::string, std::string> params; |
338 std::map<std::string, std::string> params; | 177 params["x"] = "1"; |
339 params["x"] = "1"; | 178 AssociateFieldTrialParams(kTrialName, "A", params); |
340 variations::AssociateVariationParams(kTrialName, "A", params); | 179 scoped_refptr<FieldTrial> trial( |
341 scoped_refptr<base::FieldTrial> trial( | 180 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
342 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 181 |
343 | 182 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE, |
344 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE, | 183 trial.get()); |
345 trial.get()); | 184 |
346 | 185 std::map<std::string, std::string> actualParams; |
347 std::map<std::string, std::string> actualParams; | 186 EXPECT_TRUE(GetFieldTrialParamsByFeature(kFeature, &actualParams)); |
348 EXPECT_TRUE(GetVariationParamsByFeature(kFeature, &actualParams)); | |
349 EXPECT_EQ(params, actualParams); | 187 EXPECT_EQ(params, actualParams); |
350 } | 188 } |
351 | 189 |
352 TEST_F(VariationsAssociatedDataTest, GetVariationParamValueByFeature) { | 190 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature) { |
353 const std::string kTrialName = "GetVariationParamsByFeature"; | 191 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
354 const base::Feature kFeature{"TestFeature", | 192 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
355 base::FEATURE_DISABLED_BY_DEFAULT}; | 193 |
356 | 194 std::map<std::string, std::string> params; |
357 std::map<std::string, std::string> params; | 195 params["x"] = "1"; |
358 params["x"] = "1"; | 196 AssociateFieldTrialParams(kTrialName, "A", params); |
359 variations::AssociateVariationParams(kTrialName, "A", params); | 197 scoped_refptr<FieldTrial> trial( |
360 scoped_refptr<base::FieldTrial> trial( | 198 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
361 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 199 |
362 | 200 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE, |
363 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE, | 201 trial.get()); |
364 trial.get()); | 202 |
365 | 203 std::map<std::string, std::string> actualParams; |
366 std::map<std::string, std::string> actualParams; | 204 EXPECT_EQ(params["x"], GetFieldTrialParamValueByFeature(kFeature, "x")); |
367 EXPECT_EQ(params["x"], GetVariationParamValueByFeature(kFeature, "x")); | 205 } |
368 } | 206 |
369 | 207 TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature_Disable) { |
370 TEST_F(VariationsAssociatedDataTest, GetVariationParamsByFeature_Disable) { | 208 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
371 const std::string kTrialName = "GetVariationParamsByFeature"; | 209 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
372 const base::Feature kFeature{"TestFeature", | 210 |
373 base::FEATURE_DISABLED_BY_DEFAULT}; | 211 std::map<std::string, std::string> params; |
374 | 212 params["x"] = "1"; |
375 std::map<std::string, std::string> params; | 213 AssociateFieldTrialParams(kTrialName, "A", params); |
376 params["x"] = "1"; | 214 scoped_refptr<FieldTrial> trial( |
377 variations::AssociateVariationParams(kTrialName, "A", params); | 215 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
378 scoped_refptr<base::FieldTrial> trial( | 216 |
379 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 217 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE, |
380 | 218 trial.get()); |
381 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_DISABLE_FEATURE, | 219 |
382 trial.get()); | 220 std::map<std::string, std::string> actualParams; |
383 | 221 EXPECT_FALSE(GetFieldTrialParamsByFeature(kFeature, &actualParams)); |
384 std::map<std::string, std::string> actualParams; | 222 } |
385 EXPECT_FALSE(GetVariationParamsByFeature(kFeature, &actualParams)); | 223 |
386 } | 224 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature_Disable) { |
387 | 225 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
388 TEST_F(VariationsAssociatedDataTest, GetVariationParamValueByFeature_Disable) { | 226 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
389 const std::string kTrialName = "GetVariationParamsByFeature"; | 227 |
390 const base::Feature kFeature{"TestFeature", | 228 std::map<std::string, std::string> params; |
391 base::FEATURE_DISABLED_BY_DEFAULT}; | 229 params["x"] = "1"; |
392 | 230 AssociateFieldTrialParams(kTrialName, "A", params); |
393 std::map<std::string, std::string> params; | 231 scoped_refptr<FieldTrial> trial( |
394 params["x"] = "1"; | 232 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
395 variations::AssociateVariationParams(kTrialName, "A", params); | 233 |
396 scoped_refptr<base::FieldTrial> trial( | 234 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE, |
397 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 235 trial.get()); |
398 | 236 |
399 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_DISABLE_FEATURE, | 237 std::map<std::string, std::string> actualParams; |
400 trial.get()); | 238 EXPECT_EQ(std::string(), GetFieldTrialParamValueByFeature(kFeature, "x")); |
401 | 239 } |
402 std::map<std::string, std::string> actualParams; | 240 |
403 EXPECT_EQ(std::string(), GetVariationParamValueByFeature(kFeature, "x")); | 241 TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsInt) { |
404 } | 242 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
405 | 243 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
406 TEST_F(VariationsAssociatedDataTest, GetVariationParamByFeatureAsInt) { | |
407 const std::string kTrialName = "GetVariationParamsByFeature"; | |
408 const base::Feature kFeature{"TestFeature", | |
409 base::FEATURE_DISABLED_BY_DEFAULT}; | |
410 | 244 |
411 std::map<std::string, std::string> params; | 245 std::map<std::string, std::string> params; |
412 params["a"] = "1"; | 246 params["a"] = "1"; |
413 params["b"] = "1.5"; | 247 params["b"] = "1.5"; |
414 params["c"] = "foo"; | 248 params["c"] = "foo"; |
415 params["d"] = ""; | 249 params["d"] = ""; |
416 // "e" is not registered | 250 // "e" is not registered |
417 variations::AssociateVariationParams(kTrialName, "A", params); | 251 AssociateFieldTrialParams(kTrialName, "A", params); |
418 scoped_refptr<base::FieldTrial> trial( | 252 scoped_refptr<FieldTrial> trial( |
419 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 253 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
420 | 254 |
421 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE, | 255 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE, |
422 trial.get()); | 256 trial.get()); |
423 | 257 |
424 std::map<std::string, std::string> actualParams; | 258 std::map<std::string, std::string> actualParams; |
425 EXPECT_EQ(1, GetVariationParamByFeatureAsInt(kFeature, "a", 0)); | 259 EXPECT_EQ(1, GetFieldTrialParamByFeatureAsInt(kFeature, "a", 0)); |
426 EXPECT_EQ(0, GetVariationParamByFeatureAsInt(kFeature, "b", 0)); // invalid | 260 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "b", 0)); // invalid |
427 EXPECT_EQ(0, GetVariationParamByFeatureAsInt(kFeature, "c", 0)); // invalid | 261 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "c", 0)); // invalid |
428 EXPECT_EQ(0, GetVariationParamByFeatureAsInt(kFeature, "d", 0)); // empty | 262 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "d", 0)); // empty |
429 EXPECT_EQ(0, GetVariationParamByFeatureAsInt(kFeature, "e", 0)); // empty | 263 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "e", 0)); // empty |
430 } | 264 } |
431 | 265 |
432 TEST_F(VariationsAssociatedDataTest, GetVariationParamByFeatureAsDouble) { | 266 TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsDouble) { |
433 const std::string kTrialName = "GetVariationParamsByFeature"; | 267 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
434 const base::Feature kFeature{"TestFeature", | 268 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
435 base::FEATURE_DISABLED_BY_DEFAULT}; | |
436 | 269 |
437 std::map<std::string, std::string> params; | 270 std::map<std::string, std::string> params; |
438 params["a"] = "1"; | 271 params["a"] = "1"; |
439 params["b"] = "1.5"; | 272 params["b"] = "1.5"; |
440 params["c"] = "1.0e-10"; | 273 params["c"] = "1.0e-10"; |
441 params["d"] = "foo"; | 274 params["d"] = "foo"; |
442 params["e"] = ""; | 275 params["e"] = ""; |
443 // "f" is not registered | 276 // "f" is not registered |
444 variations::AssociateVariationParams(kTrialName, "A", params); | 277 AssociateFieldTrialParams(kTrialName, "A", params); |
445 scoped_refptr<base::FieldTrial> trial( | 278 scoped_refptr<FieldTrial> trial( |
446 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 279 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
447 | 280 |
448 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE, | 281 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE, |
449 trial.get()); | 282 trial.get()); |
450 | 283 |
451 std::map<std::string, std::string> actualParams; | 284 std::map<std::string, std::string> actualParams; |
452 EXPECT_EQ(1, GetVariationParamByFeatureAsDouble(kFeature, "a", 0)); | 285 EXPECT_EQ(1, GetFieldTrialParamByFeatureAsDouble(kFeature, "a", 0)); |
453 EXPECT_EQ(1.5, GetVariationParamByFeatureAsDouble(kFeature, "b", 0)); | 286 EXPECT_EQ(1.5, GetFieldTrialParamByFeatureAsDouble(kFeature, "b", 0)); |
454 EXPECT_EQ(1.0e-10, GetVariationParamByFeatureAsDouble(kFeature, "c", 0)); | 287 EXPECT_EQ(1.0e-10, GetFieldTrialParamByFeatureAsDouble(kFeature, "c", 0)); |
455 EXPECT_EQ(0, | 288 EXPECT_EQ(0, |
456 GetVariationParamByFeatureAsDouble(kFeature, "d", 0)); // invalid | 289 GetFieldTrialParamByFeatureAsDouble(kFeature, "d", 0)); // invalid |
457 EXPECT_EQ(0, GetVariationParamByFeatureAsDouble(kFeature, "e", 0)); // empty | 290 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "e", 0)); // empty |
458 EXPECT_EQ(0, GetVariationParamByFeatureAsDouble(kFeature, "f", 0)); // empty | 291 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "f", 0)); // empty |
459 } | 292 } |
460 | 293 |
461 TEST_F(VariationsAssociatedDataTest, GetVariationParamByFeatureAsBool) { | 294 TEST_F(FieldTrialParamsTest, GetFieldTrialParamByFeatureAsBool) { |
462 const std::string kTrialName = "GetVariationParamsByFeature"; | 295 const std::string kTrialName = "GetFieldTrialParamsByFeature"; |
463 const base::Feature kFeature{"TestFeature", | 296 const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT}; |
464 base::FEATURE_DISABLED_BY_DEFAULT}; | |
465 | 297 |
466 std::map<std::string, std::string> params; | 298 std::map<std::string, std::string> params; |
467 params["a"] = "true"; | 299 params["a"] = "true"; |
468 params["b"] = "false"; | 300 params["b"] = "false"; |
469 params["c"] = "1"; | 301 params["c"] = "1"; |
470 params["d"] = "False"; | 302 params["d"] = "False"; |
471 params["e"] = ""; | 303 params["e"] = ""; |
472 // "f" is not registered | 304 // "f" is not registered |
473 variations::AssociateVariationParams(kTrialName, "A", params); | 305 AssociateFieldTrialParams(kTrialName, "A", params); |
474 scoped_refptr<base::FieldTrial> trial( | 306 scoped_refptr<FieldTrial> trial( |
475 CreateFieldTrial(kTrialName, 100, "A", NULL)); | 307 CreateFieldTrial(kTrialName, 100, "A", nullptr)); |
476 | 308 |
477 CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE, | 309 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE, |
478 trial.get()); | 310 trial.get()); |
479 | 311 |
480 std::map<std::string, std::string> actualParams; | 312 std::map<std::string, std::string> actualParams; |
481 EXPECT_TRUE(GetVariationParamByFeatureAsBool(kFeature, "a", false)); | 313 EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "a", false)); |
482 EXPECT_FALSE(GetVariationParamByFeatureAsBool(kFeature, "b", true)); | 314 EXPECT_FALSE(GetFieldTrialParamByFeatureAsBool(kFeature, "b", true)); |
483 EXPECT_FALSE( | 315 EXPECT_FALSE( |
484 GetVariationParamByFeatureAsBool(kFeature, "c", false)); // invalid | 316 GetFieldTrialParamByFeatureAsBool(kFeature, "c", false)); // invalid |
485 EXPECT_TRUE( | 317 EXPECT_TRUE( |
486 GetVariationParamByFeatureAsBool(kFeature, "d", true)); // invalid | 318 GetFieldTrialParamByFeatureAsBool(kFeature, "d", true)); // invalid |
487 EXPECT_TRUE(GetVariationParamByFeatureAsBool(kFeature, "e", true)); // empty | 319 EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "e", true)); // empty |
488 EXPECT_TRUE(GetVariationParamByFeatureAsBool(kFeature, "f", true)); // empty | 320 EXPECT_TRUE(GetFieldTrialParamByFeatureAsBool(kFeature, "f", true)); // empty |
489 } | 321 } |
490 | 322 |
491 } // namespace variations | 323 } // namespace base |
OLD | NEW |