1 /*
2 * Copyright 2018 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "rtc_base/experiments/field_trial_parser.h"
11
12 #include "absl/strings/string_view.h"
13 #include "rtc_base/experiments/field_trial_list.h"
14 #include "rtc_base/gunit.h"
15 #include "system_wrappers/include/field_trial.h"
16 #include "test/field_trial.h"
17 #include "test/gmock.h"
18
19 namespace webrtc {
20 namespace {
21
22 constexpr char kDummyExperiment[] = "WebRTC-DummyExperiment";
23
24 struct DummyExperiment {
25 FieldTrialFlag enabled = FieldTrialFlag("Enabled");
26 FieldTrialParameter<double> factor = FieldTrialParameter<double>("f", 0.5);
27 FieldTrialParameter<int> retries = FieldTrialParameter<int>("r", 5);
28 FieldTrialParameter<unsigned> size = FieldTrialParameter<unsigned>("s", 3);
29 FieldTrialParameter<bool> ping = FieldTrialParameter<bool>("p", 0);
30 FieldTrialParameter<std::string> hash =
31 FieldTrialParameter<std::string>("h", "a80");
32
33 field_trial::FieldTrialsAllowedInScopeForTesting k{{kDummyExperiment}};
34
DummyExperimentwebrtc::__anon31d662100111::DummyExperiment35 DummyExperiment()
36 : DummyExperiment(field_trial::FindFullName(kDummyExperiment)) {}
37
DummyExperimentwebrtc::__anon31d662100111::DummyExperiment38 explicit DummyExperiment(absl::string_view field_trial) {
39 ParseFieldTrial({&enabled, &factor, &retries, &size, &ping, &hash},
40 field_trial);
41 }
42 };
43
44 enum class CustomEnum {
45 kDefault = 0,
46 kRed = 1,
47 kBlue = 2,
48 };
49
50 } // namespace
51
TEST(FieldTrialParserTest,ParsesValidParameters)52 TEST(FieldTrialParserTest, ParsesValidParameters) {
53 DummyExperiment exp("Enabled,f:-1.7,r:2,s:10,p:1,h:x7c");
54 EXPECT_TRUE(exp.enabled.Get());
55 EXPECT_EQ(exp.factor.Get(), -1.7);
56 EXPECT_EQ(exp.retries.Get(), 2);
57 EXPECT_EQ(exp.size.Get(), 10u);
58 EXPECT_EQ(exp.ping.Get(), true);
59 EXPECT_EQ(exp.hash.Get(), "x7c");
60 }
TEST(FieldTrialParserTest,InitializesFromFieldTrial)61 TEST(FieldTrialParserTest, InitializesFromFieldTrial) {
62 test::ScopedFieldTrials field_trials(
63 "WebRTC-OtherExperiment/Disabled/"
64 "WebRTC-DummyExperiment/Enabled,f:-1.7,r:2,s:10,p:1,h:x7c/"
65 "WebRTC-AnotherExperiment/Enabled,f:-3.1,otherstuff:beef/");
66 DummyExperiment exp;
67 EXPECT_TRUE(exp.enabled.Get());
68 EXPECT_EQ(exp.factor.Get(), -1.7);
69 EXPECT_EQ(exp.retries.Get(), 2);
70 EXPECT_EQ(exp.size.Get(), 10u);
71 EXPECT_EQ(exp.ping.Get(), true);
72 EXPECT_EQ(exp.hash.Get(), "x7c");
73 }
TEST(FieldTrialParserTest,UsesDefaults)74 TEST(FieldTrialParserTest, UsesDefaults) {
75 DummyExperiment exp("");
76 EXPECT_FALSE(exp.enabled.Get());
77 EXPECT_EQ(exp.factor.Get(), 0.5);
78 EXPECT_EQ(exp.retries.Get(), 5);
79 EXPECT_EQ(exp.size.Get(), 3u);
80 EXPECT_EQ(exp.ping.Get(), false);
81 EXPECT_EQ(exp.hash.Get(), "a80");
82 }
TEST(FieldTrialParserTest,CanHandleMixedInput)83 TEST(FieldTrialParserTest, CanHandleMixedInput) {
84 DummyExperiment exp("p:true,h:,Enabled");
85 EXPECT_TRUE(exp.enabled.Get());
86 EXPECT_EQ(exp.factor.Get(), 0.5);
87 EXPECT_EQ(exp.retries.Get(), 5);
88 EXPECT_EQ(exp.size.Get(), 3u);
89 EXPECT_EQ(exp.ping.Get(), true);
90 EXPECT_EQ(exp.hash.Get(), "");
91 }
TEST(FieldTrialParserTest,ParsesDoubleParameter)92 TEST(FieldTrialParserTest, ParsesDoubleParameter) {
93 FieldTrialParameter<double> double_param("f", 0.0);
94 ParseFieldTrial({&double_param}, "f:45%");
95 EXPECT_EQ(double_param.Get(), 0.45);
96 ParseFieldTrial({&double_param}, "f:34 %");
97 EXPECT_EQ(double_param.Get(), 0.34);
98 ParseFieldTrial({&double_param}, "f:0.67");
99 EXPECT_EQ(double_param.Get(), 0.67);
100 }
TEST(FieldTrialParserTest,IgnoresNewKey)101 TEST(FieldTrialParserTest, IgnoresNewKey) {
102 DummyExperiment exp("Disabled,r:-11,foo");
103 EXPECT_FALSE(exp.enabled.Get());
104 EXPECT_EQ(exp.factor.Get(), 0.5);
105 EXPECT_EQ(exp.retries.Get(), -11);
106 }
TEST(FieldTrialParserTest,IgnoresInvalid)107 TEST(FieldTrialParserTest, IgnoresInvalid) {
108 DummyExperiment exp("Enabled,f,p:,r:%,,s:-1,:foo,h");
109 EXPECT_TRUE(exp.enabled.Get());
110 EXPECT_EQ(exp.factor.Get(), 0.5);
111 EXPECT_EQ(exp.retries.Get(), 5);
112 EXPECT_EQ(exp.size.Get(), 3u);
113 EXPECT_EQ(exp.ping.Get(), false);
114 EXPECT_EQ(exp.hash.Get(), "a80");
115 }
TEST(FieldTrialParserTest,IgnoresOutOfRange)116 TEST(FieldTrialParserTest, IgnoresOutOfRange) {
117 FieldTrialConstrained<double> low("low", 10, absl::nullopt, 100);
118 FieldTrialConstrained<double> high("high", 10, 5, absl::nullopt);
119 ParseFieldTrial({&low, &high}, "low:1000,high:0");
120 EXPECT_EQ(low.Get(), 10);
121 EXPECT_EQ(high.Get(), 10);
122 ParseFieldTrial({&low, &high}, "low:inf,high:nan");
123 EXPECT_EQ(low.Get(), 10);
124 EXPECT_EQ(high.Get(), 10);
125 ParseFieldTrial({&low, &high}, "low:20,high:20");
126 EXPECT_EQ(low.Get(), 20);
127 EXPECT_EQ(high.Get(), 20);
128
129 FieldTrialConstrained<unsigned> size("size", 5, 1, 10);
130 ParseFieldTrial({&size}, "size:0");
131 EXPECT_EQ(size.Get(), 5u);
132 }
TEST(FieldTrialParserTest,ReadsValuesFromFieldWithoutKey)133 TEST(FieldTrialParserTest, ReadsValuesFromFieldWithoutKey) {
134 FieldTrialFlag enabled("Enabled");
135 FieldTrialParameter<int> req("", 10);
136 ParseFieldTrial({&enabled, &req}, "Enabled,20");
137 EXPECT_EQ(req.Get(), 20);
138 ParseFieldTrial({&req}, "30");
139 EXPECT_EQ(req.Get(), 30);
140 }
TEST(FieldTrialParserTest,ParsesOptionalParameters)141 TEST(FieldTrialParserTest, ParsesOptionalParameters) {
142 FieldTrialOptional<int> max_count("c", absl::nullopt);
143 ParseFieldTrial({&max_count}, "");
144 EXPECT_FALSE(max_count.GetOptional().has_value());
145 ParseFieldTrial({&max_count}, "c:10");
146 EXPECT_EQ(max_count.GetOptional().value(), 10);
147 ParseFieldTrial({&max_count}, "c");
148 EXPECT_FALSE(max_count.GetOptional().has_value());
149 ParseFieldTrial({&max_count}, "c:20");
150 EXPECT_EQ(max_count.GetOptional().value(), 20);
151 ParseFieldTrial({&max_count}, "c:");
152 EXPECT_EQ(max_count.GetOptional().value(), 20);
153
154 FieldTrialOptional<unsigned> max_size("c", absl::nullopt);
155 ParseFieldTrial({&max_size}, "");
156 EXPECT_FALSE(max_size.GetOptional().has_value());
157 ParseFieldTrial({&max_size}, "c:10");
158 EXPECT_EQ(max_size.GetOptional().value(), 10u);
159 ParseFieldTrial({&max_size}, "c");
160 EXPECT_FALSE(max_size.GetOptional().has_value());
161 ParseFieldTrial({&max_size}, "c:20");
162 EXPECT_EQ(max_size.GetOptional().value(), 20u);
163
164 FieldTrialOptional<std::string> optional_string("s", std::string("ab"));
165 ParseFieldTrial({&optional_string}, "s:");
166 EXPECT_EQ(optional_string.GetOptional().value(), "");
167 ParseFieldTrial({&optional_string}, "s");
168 EXPECT_FALSE(optional_string.GetOptional().has_value());
169 }
TEST(FieldTrialParserTest,ParsesCustomEnumParameter)170 TEST(FieldTrialParserTest, ParsesCustomEnumParameter) {
171 FieldTrialEnum<CustomEnum> my_enum("e", CustomEnum::kDefault,
172 {{"default", CustomEnum::kDefault},
173 {"red", CustomEnum::kRed},
174 {"blue", CustomEnum::kBlue}});
175 ParseFieldTrial({&my_enum}, "");
176 EXPECT_EQ(my_enum.Get(), CustomEnum::kDefault);
177 ParseFieldTrial({&my_enum}, "e:red");
178 EXPECT_EQ(my_enum.Get(), CustomEnum::kRed);
179 ParseFieldTrial({&my_enum}, "e:2");
180 EXPECT_EQ(my_enum.Get(), CustomEnum::kBlue);
181 ParseFieldTrial({&my_enum}, "e:5");
182 EXPECT_EQ(my_enum.Get(), CustomEnum::kBlue);
183 }
184
185 } // namespace webrtc
186