1 // Copyright 2023 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "components/miracle_parameter/common/public/miracle_parameter.h"
6 
7 #include "base/command_line.h"
8 #include "base/feature_list.h"
9 #include "base/metrics/field_trial.h"
10 #include "base/metrics/field_trial_param_associator.h"
11 #include "base/test/mock_entropy_provider.h"
12 #include "base/test/scoped_amount_of_physical_memory_override.h"
13 #include "base/test/scoped_feature_list.h"
14 #include "base/time/time.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16 
17 namespace miracle_parameter {
18 
19 namespace {
20 
21 // Call FieldTrialList::FactoryGetFieldTrial().
CreateFieldTrial(const std::string & trial_name,int total_probability,const std::string & default_group_name)22 scoped_refptr<base::FieldTrial> CreateFieldTrial(
23     const std::string& trial_name,
24     int total_probability,
25     const std::string& default_group_name) {
26   base::MockEntropyProvider entropy_provider(0.9);
27   return base::FieldTrialList::FactoryGetFieldTrial(
28       trial_name, total_probability, default_group_name, entropy_provider);
29 }
30 
BoolToString(bool value)31 const std::string BoolToString(bool value) {
32   return value ? "true" : "false";
33 }
34 
35 class ScopedNullCommandLineOverride {
36  public:
ScopedNullCommandLineOverride()37   ScopedNullCommandLineOverride()
38       : process_args_(base::CommandLine::ForCurrentProcess()->GetArgs()) {
39     base::CommandLine::Reset();
40   }
41   ScopedNullCommandLineOverride(const ScopedNullCommandLineOverride&) = delete;
42   ScopedNullCommandLineOverride& operator=(
43       const ScopedNullCommandLineOverride&) = delete;
~ScopedNullCommandLineOverride()44   ~ScopedNullCommandLineOverride() {
45     base::CommandLine::Init(0, nullptr);
46     base::CommandLine::ForCurrentProcess()->InitFromArgv(process_args_);
47   }
48 
49  private:
50   const base::CommandLine::StringVector process_args_;
51 };
52 
53 }  // namespace
54 
55 class MiracleParameterTest : public ::testing::Test {
56  public:
57   MiracleParameterTest() = default;
58 
59   MiracleParameterTest(const MiracleParameterTest&) = delete;
60   MiracleParameterTest& operator=(const MiracleParameterTest&) = delete;
61 
~MiracleParameterTest()62   ~MiracleParameterTest() override {
63     // Ensure that the maps are cleared between tests, since they are stored as
64     // process singletons.
65     base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
66   }
67 
CreateFeatureWithTrial(const base::Feature & feature,base::FeatureList::OverrideState override_state,base::FieldTrial * trial)68   void CreateFeatureWithTrial(const base::Feature& feature,
69                               base::FeatureList::OverrideState override_state,
70                               base::FieldTrial* trial) {
71     auto feature_list = std::make_unique<base::FeatureList>();
72     feature_list->RegisterFieldTrialOverride(feature.name, override_state,
73                                              trial);
74     scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
75   }
76 
77  private:
78   base::test::ScopedFeatureList scoped_feature_list_;
79 };
80 
TEST_F(MiracleParameterTest,MiracleParameterForString)81 TEST_F(MiracleParameterTest, MiracleParameterForString) {
82   const char kAForLessThan512MB[] = "a-value-for-less-than-512mb";
83   const char kAFor512MBTo1GB[] = "a-value-for-512mb-to-1gb";
84   const char kAFor1GBTo2GB[] = "a-value-for-1gb-to-2gb";
85   const char kAFor2GBTo4GB[] = "a-value-for-2gb-to-4gb";
86   const char kAFor4GBTo8GB[] = "a-value-for-4gb-to-8gb";
87   const char kAFor8GBTo16GB[] = "a-value-for-8gb-to-16gb";
88   const char kAFor16GBAndAbove[] = "a-value-for-16gb-and-above";
89   const char kAParamValue[] = "a-param-value";
90   const char kCParamValue[] = "c-param-value";
91   const char kADefault[] = "default-for-a";
92   const char kBDefault[] = "default-for-b";
93   const char kCDefault[] = "default-for-c";
94 
95   // Set up the field trial params.
96   const std::string kTrialName = "TrialName";
97   std::map<std::string, std::string> params;
98   params["aForLessThan512MB"] = kAForLessThan512MB;
99   params["aFor512MBTo1GB"] = kAFor512MBTo1GB;
100   params["aFor1GBTo2GB"] = kAFor1GBTo2GB;
101   params["aFor2GBTo4GB"] = kAFor2GBTo4GB;
102   params["aFor4GBTo8GB"] = kAFor4GBTo8GB;
103   params["aFor8GBTo16GB"] = kAFor8GBTo16GB;
104   params["aFor16GBAndAbove"] = kAFor16GBAndAbove;
105   params["a"] = kAParamValue;
106   params["c"] = kCParamValue;
107   base::AssociateFieldTrialParams(kTrialName, "A", params);
108   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
109       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
110   static BASE_FEATURE(kFeature, "TestFeature",
111                       base::FEATURE_ENABLED_BY_DEFAULT);
112   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
113                          trial.get());
114 
115   auto GetParamA = [&]() {
116     return GetMiracleParameterAsString(kFeature, "a", kADefault);
117   };
118   auto GetParamB = [&]() {
119     return GetMiracleParameterAsString(kFeature, "b", kBDefault);
120   };
121   auto GetParamC = [&]() {
122     return GetMiracleParameterAsString(kFeature, "c", kCDefault);
123   };
124 
125   {
126     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
127         kMiracleParameterMemory512MB - 1);
128     EXPECT_EQ(kAForLessThan512MB, GetParamA());
129     EXPECT_EQ(kBDefault, GetParamB());
130     EXPECT_EQ(kCParamValue, GetParamC());
131   }
132   {
133     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
134         kMiracleParameterMemory512MB);
135     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
136     EXPECT_EQ(kBDefault, GetParamB());
137     EXPECT_EQ(kCParamValue, GetParamC());
138   }
139   {
140     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
141         kMiracleParameterMemory1GB - 1);
142     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
143     EXPECT_EQ(kBDefault, GetParamB());
144     EXPECT_EQ(kCParamValue, GetParamC());
145   }
146   {
147     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
148         kMiracleParameterMemory1GB);
149     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
150     EXPECT_EQ(kBDefault, GetParamB());
151     EXPECT_EQ(kCParamValue, GetParamC());
152   }
153   {
154     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
155         kMiracleParameterMemory2GB - 1);
156     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
157     EXPECT_EQ(kBDefault, GetParamB());
158     EXPECT_EQ(kCParamValue, GetParamC());
159   }
160   {
161     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
162         kMiracleParameterMemory2GB);
163     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
164     EXPECT_EQ(kBDefault, GetParamB());
165     EXPECT_EQ(kCParamValue, GetParamC());
166   }
167   {
168     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
169         kMiracleParameterMemory4GB - 1);
170     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
171     EXPECT_EQ(kBDefault, GetParamB());
172     EXPECT_EQ(kCParamValue, GetParamC());
173   }
174   {
175     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
176         kMiracleParameterMemory4GB);
177     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
178     EXPECT_EQ(kBDefault, GetParamB());
179     EXPECT_EQ(kCParamValue, GetParamC());
180   }
181   {
182     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
183         kMiracleParameterMemory8GB - 1);
184     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
185     EXPECT_EQ(kBDefault, GetParamB());
186     EXPECT_EQ(kCParamValue, GetParamC());
187   }
188   {
189     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
190         kMiracleParameterMemory8GB);
191     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
192     EXPECT_EQ(kBDefault, GetParamB());
193     EXPECT_EQ(kCParamValue, GetParamC());
194   }
195   {
196     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
197         kMiracleParameterMemory16GB - 1);
198     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
199     EXPECT_EQ(kBDefault, GetParamB());
200     EXPECT_EQ(kCParamValue, GetParamC());
201   }
202   {
203     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
204         kMiracleParameterMemory16GB);
205     EXPECT_EQ(kAFor16GBAndAbove, GetParamA());
206     EXPECT_EQ(kBDefault, GetParamB());
207     EXPECT_EQ(kCParamValue, GetParamC());
208   }
209   {
210     ScopedNullCommandLineOverride null_command_line_override;
211     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
212         kMiracleParameterMemory16GB);
213     EXPECT_EQ(kAParamValue, GetParamA());
214     EXPECT_EQ(kBDefault, GetParamB());
215     EXPECT_EQ(kCParamValue, GetParamC());
216   }
217 }
218 
TEST_F(MiracleParameterTest,MiracleParameterForDouble)219 TEST_F(MiracleParameterTest, MiracleParameterForDouble) {
220   const double kAForLessThan512MB = 0.1;
221   const double kAFor512MBTo1GB = 0.2;
222   const double kAFor1GBTo2GB = 0.3;
223   const double kAFor2GBTo4GB = 0.4;
224   const double kAFor4GBTo8GB = 0.5;
225   const double kAFor8GBTo16GB = 0.6;
226   const double kAFor16GBAndAbove = 0.7;
227   const double kAParamValue = 0.8;
228   const double kCParamValue = 0.9;
229   const double kADefault = 1.0;
230   const double kBDefault = 1.1;
231   const double kCDefault = 1.2;
232 
233   // Set up the field trial params.
234   const std::string kTrialName = "TrialName";
235   std::map<std::string, std::string> params;
236   params["aForLessThan512MB"] = base::ToString(kAForLessThan512MB);
237   params["aFor512MBTo1GB"] = base::ToString(kAFor512MBTo1GB);
238   params["aFor1GBTo2GB"] = base::ToString(kAFor1GBTo2GB);
239   params["aFor2GBTo4GB"] = base::ToString(kAFor2GBTo4GB);
240   params["aFor4GBTo8GB"] = base::ToString(kAFor4GBTo8GB);
241   params["aFor8GBTo16GB"] = base::ToString(kAFor8GBTo16GB);
242   params["aFor16GBAndAbove"] = base::ToString(kAFor16GBAndAbove);
243   params["a"] = base::ToString(kAParamValue);
244   params["c"] = base::ToString(kCParamValue);
245   base::AssociateFieldTrialParams(kTrialName, "A", params);
246   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
247       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
248   static BASE_FEATURE(kFeature, "TestFeature",
249                       base::FEATURE_ENABLED_BY_DEFAULT);
250   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
251                          trial.get());
252 
253   auto GetParamA = [&]() {
254     return GetMiracleParameterAsDouble(kFeature, "a", kADefault);
255   };
256   auto GetParamB = [&]() {
257     return GetMiracleParameterAsDouble(kFeature, "b", kBDefault);
258   };
259   auto GetParamC = [&]() {
260     return GetMiracleParameterAsDouble(kFeature, "c", kCDefault);
261   };
262 
263   {
264     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
265         kMiracleParameterMemory512MB - 1);
266     EXPECT_EQ(kAForLessThan512MB, GetParamA());
267     EXPECT_EQ(kBDefault, GetParamB());
268     EXPECT_EQ(kCParamValue, GetParamC());
269   }
270   {
271     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
272         kMiracleParameterMemory512MB);
273     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
274     EXPECT_EQ(kBDefault, GetParamB());
275     EXPECT_EQ(kCParamValue, GetParamC());
276   }
277   {
278     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
279         kMiracleParameterMemory1GB - 1);
280     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
281     EXPECT_EQ(kBDefault, GetParamB());
282     EXPECT_EQ(kCParamValue, GetParamC());
283   }
284   {
285     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
286         kMiracleParameterMemory1GB);
287     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
288     EXPECT_EQ(kBDefault, GetParamB());
289     EXPECT_EQ(kCParamValue, GetParamC());
290   }
291   {
292     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
293         kMiracleParameterMemory2GB - 1);
294     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
295     EXPECT_EQ(kBDefault, GetParamB());
296     EXPECT_EQ(kCParamValue, GetParamC());
297   }
298   {
299     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
300         kMiracleParameterMemory2GB);
301     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
302     EXPECT_EQ(kBDefault, GetParamB());
303     EXPECT_EQ(kCParamValue, GetParamC());
304   }
305   {
306     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
307         kMiracleParameterMemory4GB - 1);
308     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
309     EXPECT_EQ(kBDefault, GetParamB());
310     EXPECT_EQ(kCParamValue, GetParamC());
311   }
312   {
313     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
314         kMiracleParameterMemory4GB);
315     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
316     EXPECT_EQ(kBDefault, GetParamB());
317     EXPECT_EQ(kCParamValue, GetParamC());
318   }
319   {
320     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
321         kMiracleParameterMemory8GB - 1);
322     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
323     EXPECT_EQ(kBDefault, GetParamB());
324     EXPECT_EQ(kCParamValue, GetParamC());
325   }
326   {
327     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
328         kMiracleParameterMemory8GB);
329     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
330     EXPECT_EQ(kBDefault, GetParamB());
331     EXPECT_EQ(kCParamValue, GetParamC());
332   }
333   {
334     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
335         kMiracleParameterMemory16GB - 1);
336     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
337     EXPECT_EQ(kBDefault, GetParamB());
338     EXPECT_EQ(kCParamValue, GetParamC());
339   }
340   {
341     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
342         kMiracleParameterMemory16GB);
343     EXPECT_EQ(kAFor16GBAndAbove, GetParamA());
344     EXPECT_EQ(kBDefault, GetParamB());
345     EXPECT_EQ(kCParamValue, GetParamC());
346   }
347   {
348     ScopedNullCommandLineOverride null_command_line_override;
349     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
350         kMiracleParameterMemory16GB);
351     EXPECT_EQ(kAParamValue, GetParamA());
352     EXPECT_EQ(kBDefault, GetParamB());
353     EXPECT_EQ(kCParamValue, GetParamC());
354   }
355 }
356 
TEST_F(MiracleParameterTest,MiracleParameterForInt)357 TEST_F(MiracleParameterTest, MiracleParameterForInt) {
358   const int kAForLessThan512MB = 1;
359   const int kAFor512MBTo1GB = 2;
360   const int kAFor1GBTo2GB = 3;
361   const int kAFor2GBTo4GB = 4;
362   const int kAFor4GBTo8GB = 5;
363   const int kAFor8GBTo16GB = 6;
364   const int kAFor16GBAndAbove = 7;
365   const int kAParamValue = 8;
366   const int kCParamValue = 9;
367   const int kADefault = 10;
368   const int kBDefault = 11;
369   const int kCDefault = 12;
370 
371   // Set up the field trial params.
372   const std::string kTrialName = "TrialName";
373   std::map<std::string, std::string> params;
374   params["aForLessThan512MB"] = base::ToString(kAForLessThan512MB);
375   params["aFor512MBTo1GB"] = base::ToString(kAFor512MBTo1GB);
376   params["aFor1GBTo2GB"] = base::ToString(kAFor1GBTo2GB);
377   params["aFor2GBTo4GB"] = base::ToString(kAFor2GBTo4GB);
378   params["aFor4GBTo8GB"] = base::ToString(kAFor4GBTo8GB);
379   params["aFor8GBTo16GB"] = base::ToString(kAFor8GBTo16GB);
380   params["aFor16GBAndAbove"] = base::ToString(kAFor16GBAndAbove);
381   params["a"] = base::ToString(kAParamValue);
382   params["c"] = base::ToString(kCParamValue);
383   base::AssociateFieldTrialParams(kTrialName, "A", params);
384   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
385       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
386   static BASE_FEATURE(kFeature, "TestFeature",
387                       base::FEATURE_ENABLED_BY_DEFAULT);
388   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
389                          trial.get());
390 
391   auto GetParamA = [&]() {
392     return GetMiracleParameterAsInt(kFeature, "a", kADefault);
393   };
394   auto GetParamB = [&]() {
395     return GetMiracleParameterAsInt(kFeature, "b", kBDefault);
396   };
397   auto GetParamC = [&]() {
398     return GetMiracleParameterAsInt(kFeature, "c", kCDefault);
399   };
400 
401   {
402     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
403         kMiracleParameterMemory512MB - 1);
404     EXPECT_EQ(kAForLessThan512MB, GetParamA());
405     EXPECT_EQ(kBDefault, GetParamB());
406     EXPECT_EQ(kCParamValue, GetParamC());
407   }
408   {
409     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
410         kMiracleParameterMemory512MB);
411     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
412     EXPECT_EQ(kBDefault, GetParamB());
413     EXPECT_EQ(kCParamValue, GetParamC());
414   }
415   {
416     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
417         kMiracleParameterMemory1GB - 1);
418     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
419     EXPECT_EQ(kBDefault, GetParamB());
420     EXPECT_EQ(kCParamValue, GetParamC());
421   }
422   {
423     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
424         kMiracleParameterMemory1GB);
425     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
426     EXPECT_EQ(kBDefault, GetParamB());
427     EXPECT_EQ(kCParamValue, GetParamC());
428   }
429   {
430     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
431         kMiracleParameterMemory2GB - 1);
432     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
433     EXPECT_EQ(kBDefault, GetParamB());
434     EXPECT_EQ(kCParamValue, GetParamC());
435   }
436   {
437     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
438         kMiracleParameterMemory2GB);
439     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
440     EXPECT_EQ(kBDefault, GetParamB());
441     EXPECT_EQ(kCParamValue, GetParamC());
442   }
443   {
444     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
445         kMiracleParameterMemory4GB - 1);
446     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
447     EXPECT_EQ(kBDefault, GetParamB());
448     EXPECT_EQ(kCParamValue, GetParamC());
449   }
450   {
451     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
452         kMiracleParameterMemory4GB);
453     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
454     EXPECT_EQ(kBDefault, GetParamB());
455     EXPECT_EQ(kCParamValue, GetParamC());
456   }
457   {
458     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
459         kMiracleParameterMemory8GB - 1);
460     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
461     EXPECT_EQ(kBDefault, GetParamB());
462     EXPECT_EQ(kCParamValue, GetParamC());
463   }
464   {
465     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
466         kMiracleParameterMemory8GB);
467     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
468     EXPECT_EQ(kBDefault, GetParamB());
469     EXPECT_EQ(kCParamValue, GetParamC());
470   }
471   {
472     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
473         kMiracleParameterMemory16GB - 1);
474     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
475     EXPECT_EQ(kBDefault, GetParamB());
476     EXPECT_EQ(kCParamValue, GetParamC());
477   }
478   {
479     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
480         kMiracleParameterMemory16GB);
481     EXPECT_EQ(kAFor16GBAndAbove, GetParamA());
482     EXPECT_EQ(kBDefault, GetParamB());
483     EXPECT_EQ(kCParamValue, GetParamC());
484   }
485   {
486     ScopedNullCommandLineOverride null_command_line_override;
487     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
488         kMiracleParameterMemory16GB);
489     EXPECT_EQ(kAParamValue, GetParamA());
490     EXPECT_EQ(kBDefault, GetParamB());
491     EXPECT_EQ(kCParamValue, GetParamC());
492   }
493 }
494 
TEST_F(MiracleParameterTest,MiracleParameterForBool)495 TEST_F(MiracleParameterTest, MiracleParameterForBool) {
496   const bool kAForLessThan512MB = true;
497   const bool kAFor512MBTo1GB = false;
498   const bool kAFor1GBTo2GB = true;
499   const bool kAFor2GBTo4GB = false;
500   const bool kAFor4GBTo8GB = true;
501   const bool kAFor8GBTo16GB = false;
502   const bool kAFor16GBAndAbove = true;
503   const bool kAParamValue = false;
504   const bool kCParamValue = true;
505   const bool kADefault = false;
506   const bool kBDefault = true;
507   const bool kCDefault = false;
508 
509   // Set up the field trial params.
510   const std::string kTrialName = "TrialName";
511   std::map<std::string, std::string> params;
512   params["aForLessThan512MB"] = BoolToString(kAForLessThan512MB);
513   params["aFor512MBTo1GB"] = BoolToString(kAFor512MBTo1GB);
514   params["aFor1GBTo2GB"] = BoolToString(kAFor1GBTo2GB);
515   params["aFor2GBTo4GB"] = BoolToString(kAFor2GBTo4GB);
516   params["aFor4GBTo8GB"] = BoolToString(kAFor4GBTo8GB);
517   params["aFor8GBTo16GB"] = BoolToString(kAFor8GBTo16GB);
518   params["aFor16GBAndAbove"] = BoolToString(kAFor16GBAndAbove);
519   params["a"] = BoolToString(kAParamValue);
520   params["c"] = BoolToString(kCParamValue);
521   base::AssociateFieldTrialParams(kTrialName, "A", params);
522   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
523       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
524   static BASE_FEATURE(kFeature, "TestFeature",
525                       base::FEATURE_ENABLED_BY_DEFAULT);
526   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
527                          trial.get());
528 
529   auto GetParamA = [&]() {
530     return GetMiracleParameterAsBool(kFeature, "a", kADefault);
531   };
532   auto GetParamB = [&]() {
533     return GetMiracleParameterAsBool(kFeature, "b", kBDefault);
534   };
535   auto GetParamC = [&]() {
536     return GetMiracleParameterAsBool(kFeature, "c", kCDefault);
537   };
538 
539   {
540     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
541         kMiracleParameterMemory512MB - 1);
542     EXPECT_EQ(kAForLessThan512MB, GetParamA());
543     EXPECT_EQ(kBDefault, GetParamB());
544     EXPECT_EQ(kCParamValue, GetParamC());
545   }
546   {
547     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
548         kMiracleParameterMemory512MB);
549     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
550     EXPECT_EQ(kBDefault, GetParamB());
551     EXPECT_EQ(kCParamValue, GetParamC());
552   }
553   {
554     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
555         kMiracleParameterMemory1GB - 1);
556     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
557     EXPECT_EQ(kBDefault, GetParamB());
558     EXPECT_EQ(kCParamValue, GetParamC());
559   }
560   {
561     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
562         kMiracleParameterMemory1GB);
563     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
564     EXPECT_EQ(kBDefault, GetParamB());
565     EXPECT_EQ(kCParamValue, GetParamC());
566   }
567   {
568     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
569         kMiracleParameterMemory2GB - 1);
570     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
571     EXPECT_EQ(kBDefault, GetParamB());
572     EXPECT_EQ(kCParamValue, GetParamC());
573   }
574   {
575     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
576         kMiracleParameterMemory2GB);
577     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
578     EXPECT_EQ(kBDefault, GetParamB());
579     EXPECT_EQ(kCParamValue, GetParamC());
580   }
581   {
582     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
583         kMiracleParameterMemory4GB - 1);
584     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
585     EXPECT_EQ(kBDefault, GetParamB());
586     EXPECT_EQ(kCParamValue, GetParamC());
587   }
588   {
589     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
590         kMiracleParameterMemory4GB);
591     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
592     EXPECT_EQ(kBDefault, GetParamB());
593     EXPECT_EQ(kCParamValue, GetParamC());
594   }
595   {
596     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
597         kMiracleParameterMemory8GB - 1);
598     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
599     EXPECT_EQ(kBDefault, GetParamB());
600     EXPECT_EQ(kCParamValue, GetParamC());
601   }
602   {
603     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
604         kMiracleParameterMemory8GB);
605     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
606     EXPECT_EQ(kBDefault, GetParamB());
607     EXPECT_EQ(kCParamValue, GetParamC());
608   }
609   {
610     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
611         kMiracleParameterMemory16GB - 1);
612     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
613     EXPECT_EQ(kBDefault, GetParamB());
614     EXPECT_EQ(kCParamValue, GetParamC());
615   }
616   {
617     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
618         kMiracleParameterMemory16GB);
619     EXPECT_EQ(kAFor16GBAndAbove, GetParamA());
620     EXPECT_EQ(kBDefault, GetParamB());
621     EXPECT_EQ(kCParamValue, GetParamC());
622   }
623   {
624     ScopedNullCommandLineOverride null_command_line_override;
625     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
626         kMiracleParameterMemory16GB);
627     EXPECT_EQ(kAParamValue, GetParamA());
628     EXPECT_EQ(kBDefault, GetParamB());
629     EXPECT_EQ(kCParamValue, GetParamC());
630   }
631 }
632 
TEST_F(MiracleParameterTest,MiracleParameterForTimeDelta)633 TEST_F(MiracleParameterTest, MiracleParameterForTimeDelta) {
634   const base::TimeDelta kAForLessThan512MB = base::Seconds(1);
635   const base::TimeDelta kAFor512MBTo1GB = base::Seconds(2);
636   const base::TimeDelta kAFor1GBTo2GB = base::Seconds(3);
637   const base::TimeDelta kAFor2GBTo4GB = base::Seconds(4);
638   const base::TimeDelta kAFor4GBTo8GB = base::Seconds(5);
639   const base::TimeDelta kAFor8GBTo16GB = base::Seconds(6);
640   const base::TimeDelta kAFor16GBAndAbove = base::Seconds(7);
641   const base::TimeDelta kAParamValue = base::Seconds(8);
642   const base::TimeDelta kCParamValue = base::Seconds(9);
643   const base::TimeDelta kADefault = base::Seconds(10);
644   const base::TimeDelta kBDefault = base::Seconds(11);
645   const base::TimeDelta kCDefault = base::Seconds(12);
646 
647   // Set up the field trial params.
648   const std::string kTrialName = "TrialName";
649   std::map<std::string, std::string> params;
650   params["aForLessThan512MB"] = "1s";
651   params["aFor512MBTo1GB"] = "2s";
652   params["aFor1GBTo2GB"] = "3s";
653   params["aFor2GBTo4GB"] = "4s";
654   params["aFor4GBTo8GB"] = "5s";
655   params["aFor8GBTo16GB"] = "6s";
656   params["aFor16GBAndAbove"] = "7s";
657   params["a"] = "8s";
658   params["c"] = "9s";
659   base::AssociateFieldTrialParams(kTrialName, "A", params);
660   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
661       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
662   static BASE_FEATURE(kFeature, "TestFeature",
663                       base::FEATURE_ENABLED_BY_DEFAULT);
664   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
665                          trial.get());
666 
667   auto GetParamA = [&]() {
668     return GetMiracleParameterAsTimeDelta(kFeature, "a", kADefault);
669   };
670   auto GetParamB = [&]() {
671     return GetMiracleParameterAsTimeDelta(kFeature, "b", kBDefault);
672   };
673   auto GetParamC = [&]() {
674     return GetMiracleParameterAsTimeDelta(kFeature, "c", kCDefault);
675   };
676 
677   {
678     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
679         kMiracleParameterMemory512MB - 1);
680     EXPECT_EQ(kAForLessThan512MB, GetParamA());
681     EXPECT_EQ(kBDefault, GetParamB());
682     EXPECT_EQ(kCParamValue, GetParamC());
683   }
684   {
685     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
686         kMiracleParameterMemory512MB);
687     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
688     EXPECT_EQ(kBDefault, GetParamB());
689     EXPECT_EQ(kCParamValue, GetParamC());
690   }
691   {
692     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
693         kMiracleParameterMemory1GB - 1);
694     EXPECT_EQ(kAFor512MBTo1GB, GetParamA());
695     EXPECT_EQ(kBDefault, GetParamB());
696     EXPECT_EQ(kCParamValue, GetParamC());
697   }
698   {
699     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
700         kMiracleParameterMemory1GB);
701     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
702     EXPECT_EQ(kBDefault, GetParamB());
703     EXPECT_EQ(kCParamValue, GetParamC());
704   }
705   {
706     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
707         kMiracleParameterMemory2GB - 1);
708     EXPECT_EQ(kAFor1GBTo2GB, GetParamA());
709     EXPECT_EQ(kBDefault, GetParamB());
710     EXPECT_EQ(kCParamValue, GetParamC());
711   }
712   {
713     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
714         kMiracleParameterMemory2GB);
715     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
716     EXPECT_EQ(kBDefault, GetParamB());
717     EXPECT_EQ(kCParamValue, GetParamC());
718   }
719   {
720     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
721         kMiracleParameterMemory4GB - 1);
722     EXPECT_EQ(kAFor2GBTo4GB, GetParamA());
723     EXPECT_EQ(kBDefault, GetParamB());
724     EXPECT_EQ(kCParamValue, GetParamC());
725   }
726   {
727     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
728         kMiracleParameterMemory4GB);
729     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
730     EXPECT_EQ(kBDefault, GetParamB());
731     EXPECT_EQ(kCParamValue, GetParamC());
732   }
733   {
734     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
735         kMiracleParameterMemory8GB - 1);
736     EXPECT_EQ(kAFor4GBTo8GB, GetParamA());
737     EXPECT_EQ(kBDefault, GetParamB());
738     EXPECT_EQ(kCParamValue, GetParamC());
739   }
740   {
741     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
742         kMiracleParameterMemory8GB);
743     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
744     EXPECT_EQ(kBDefault, GetParamB());
745     EXPECT_EQ(kCParamValue, GetParamC());
746   }
747   {
748     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
749         kMiracleParameterMemory16GB - 1);
750     EXPECT_EQ(kAFor8GBTo16GB, GetParamA());
751     EXPECT_EQ(kBDefault, GetParamB());
752     EXPECT_EQ(kCParamValue, GetParamC());
753   }
754   {
755     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
756         kMiracleParameterMemory16GB);
757     EXPECT_EQ(kAFor16GBAndAbove, GetParamA());
758     EXPECT_EQ(kBDefault, GetParamB());
759     EXPECT_EQ(kCParamValue, GetParamC());
760   }
761   {
762     ScopedNullCommandLineOverride null_command_line_override;
763     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
764         kMiracleParameterMemory16GB);
765     EXPECT_EQ(kAParamValue, GetParamA());
766     EXPECT_EQ(kBDefault, GetParamB());
767     EXPECT_EQ(kCParamValue, GetParamC());
768   }
769 }
770 
TEST_F(MiracleParameterTest,MiracleParameterForEnum)771 TEST_F(MiracleParameterTest, MiracleParameterForEnum) {
772   enum class ParamEnum {
773     kAForLessThan512MB,
774     kAFor512MBTo1GB,
775     kAFor1GBTo2GB,
776     kAFor2GBTo4GB,
777     kAFor4GBTo8GB,
778     kAFor8GBTo16GB,
779     kAFor16GBAndAbove,
780     kAParamValue,
781     kCParamValue,
782     kADefault,
783     kBDefault,
784     kCDefault,
785   };
786 
787   static const base::FeatureParam<ParamEnum>::Option param_enums[] = {
788       {ParamEnum::kAForLessThan512MB, "a-value-for-less-than-512mb"},
789       {ParamEnum::kAFor512MBTo1GB, "a-value-for-512mb-to-1gb"},
790       {ParamEnum::kAFor1GBTo2GB, "a-value-for-1gb-to-2gb"},
791       {ParamEnum::kAFor2GBTo4GB, "a-value-for-2gb-to-4gb"},
792       {ParamEnum::kAFor4GBTo8GB, "a-value-for-4gb-to-8gb"},
793       {ParamEnum::kAFor8GBTo16GB, "a-value-for-8gb-to-16gb"},
794       {ParamEnum::kAFor16GBAndAbove, "a-value-for-16gb-and-above"},
795       {ParamEnum::kAParamValue, "a-param-value"},
796       {ParamEnum::kCParamValue, "c-param-value"},
797       {ParamEnum::kADefault, "default-for-a"},
798       {ParamEnum::kBDefault, "default-for-b"},
799       {ParamEnum::kCDefault, "default-for-c"},
800   };
801 
802   // Set up the field trial params.
803   const std::string kTrialName = "TrialName";
804   std::map<std::string, std::string> params;
805   params["aForLessThan512MB"] = "a-value-for-less-than-512mb";
806   params["aFor512MBTo1GB"] = "a-value-for-512mb-to-1gb";
807   params["aFor1GBTo2GB"] = "a-value-for-1gb-to-2gb";
808   params["aFor2GBTo4GB"] = "a-value-for-2gb-to-4gb";
809   params["aFor4GBTo8GB"] = "a-value-for-4gb-to-8gb";
810   params["aFor8GBTo16GB"] = "a-value-for-8gb-to-16gb";
811   params["aFor16GBAndAbove"] = "a-value-for-16gb-and-above";
812   params["a"] = "a-param-value";
813   params["c"] = "c-param-value";
814   base::AssociateFieldTrialParams(kTrialName, "A", params);
815   scoped_refptr<base::FieldTrial> trial(CreateFieldTrial(
816       kTrialName, /*total_probability=*/100, /*default_group_name=*/"A"));
817   static BASE_FEATURE(kFeature, "TestFeature",
818                       base::FEATURE_ENABLED_BY_DEFAULT);
819   CreateFeatureWithTrial(kFeature, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
820                          trial.get());
821 
822   auto GetParamA = [&]() {
823     return GetMiracleParameterAsEnum(kFeature, "a", ParamEnum::kADefault,
824                                      base::make_span(param_enums));
825   };
826   auto GetParamB = [&]() {
827     return GetMiracleParameterAsEnum(kFeature, "b", ParamEnum::kBDefault,
828                                      base::make_span(param_enums));
829   };
830   auto GetParamC = [&]() {
831     return GetMiracleParameterAsEnum(kFeature, "c", ParamEnum::kCDefault,
832                                      base::make_span(param_enums));
833   };
834 
835   {
836     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
837         kMiracleParameterMemory512MB - 1);
838     EXPECT_EQ(ParamEnum::kAForLessThan512MB, GetParamA());
839     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
840     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
841   }
842   {
843     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
844         kMiracleParameterMemory512MB);
845     EXPECT_EQ(ParamEnum::kAFor512MBTo1GB, GetParamA());
846     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
847     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
848   }
849   {
850     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
851         kMiracleParameterMemory1GB - 1);
852     EXPECT_EQ(ParamEnum::kAFor512MBTo1GB, GetParamA());
853     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
854     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
855   }
856   {
857     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
858         kMiracleParameterMemory1GB);
859     EXPECT_EQ(ParamEnum::kAFor1GBTo2GB, GetParamA());
860     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
861     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
862   }
863   {
864     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
865         kMiracleParameterMemory2GB - 1);
866     EXPECT_EQ(ParamEnum::kAFor1GBTo2GB, GetParamA());
867     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
868     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
869   }
870   {
871     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
872         kMiracleParameterMemory2GB);
873     EXPECT_EQ(ParamEnum::kAFor2GBTo4GB, GetParamA());
874     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
875     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
876   }
877   {
878     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
879         kMiracleParameterMemory4GB - 1);
880     EXPECT_EQ(ParamEnum::kAFor2GBTo4GB, GetParamA());
881     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
882     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
883   }
884   {
885     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
886         kMiracleParameterMemory4GB);
887     EXPECT_EQ(ParamEnum::kAFor4GBTo8GB, GetParamA());
888     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
889     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
890   }
891   {
892     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
893         kMiracleParameterMemory8GB - 1);
894     EXPECT_EQ(ParamEnum::kAFor4GBTo8GB, GetParamA());
895     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
896     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
897   }
898   {
899     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
900         kMiracleParameterMemory8GB);
901     EXPECT_EQ(ParamEnum::kAFor8GBTo16GB, GetParamA());
902     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
903     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
904   }
905   {
906     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
907         kMiracleParameterMemory16GB - 1);
908     EXPECT_EQ(ParamEnum::kAFor8GBTo16GB, GetParamA());
909     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
910     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
911   }
912   {
913     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
914         kMiracleParameterMemory16GB);
915     EXPECT_EQ(ParamEnum::kAFor16GBAndAbove, GetParamA());
916     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
917     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
918   }
919   {
920     ScopedNullCommandLineOverride null_command_line_override;
921     base::test::ScopedAmountOfPhysicalMemoryOverride memory_override(
922         kMiracleParameterMemory16GB);
923     EXPECT_EQ(ParamEnum::kAParamValue, GetParamA());
924     EXPECT_EQ(ParamEnum::kBDefault, GetParamB());
925     EXPECT_EQ(ParamEnum::kCParamValue, GetParamC());
926   }
927 }
928 
929 }  // namespace miracle_parameter
930