| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. |
| 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 "base/trace_event/trace_config.h" |
| 6 #include "testing/gtest/include/gtest/gtest.h" |
| 7 |
| 8 namespace base { |
| 9 namespace trace_event { |
| 10 |
| 11 namespace { |
| 12 |
| 13 const char kDefaultTraceConfigString[] = |
| 14 "{" |
| 15 "\"enable_argument_filter\":false," |
| 16 "\"enable_sampling\":false," |
| 17 "\"enable_systrace\":false," |
| 18 "\"excluded_categories\":[\"*Debug\",\"*Test\"]," |
| 19 "\"record_mode\":\"record-until-full\"" |
| 20 "}"; |
| 21 |
| 22 } // namespace |
| 23 |
| 24 TEST(TraceConfigTest, TraceConfigFromValidLegacyFormat) { |
| 25 // From trace options strings |
| 26 TraceConfig config("", "record-until-full"); |
| 27 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 28 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 29 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 30 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 31 EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str()); |
| 32 |
| 33 config = TraceConfig("", "record-continuously"); |
| 34 EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode()); |
| 35 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 36 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 37 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 38 EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str()); |
| 39 |
| 40 config = TraceConfig("", "trace-to-console"); |
| 41 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 42 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 43 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 44 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 45 EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str()); |
| 46 |
| 47 config = TraceConfig("", "record-as-much-as-possible"); |
| 48 EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode()); |
| 49 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 50 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 51 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 52 EXPECT_STREQ("record-as-much-as-possible", |
| 53 config.ToTraceOptionsString().c_str()); |
| 54 |
| 55 config = TraceConfig("", "record-until-full, enable-sampling"); |
| 56 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 57 EXPECT_TRUE(config.IsSamplingEnabled()); |
| 58 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 59 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 60 EXPECT_STREQ("record-until-full,enable-sampling", |
| 61 config.ToTraceOptionsString().c_str()); |
| 62 |
| 63 config = TraceConfig("", "enable-systrace, record-continuously"); |
| 64 EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode()); |
| 65 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 66 EXPECT_TRUE(config.IsSystraceEnabled()); |
| 67 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 68 EXPECT_STREQ("record-continuously,enable-systrace", |
| 69 config.ToTraceOptionsString().c_str()); |
| 70 |
| 71 config = TraceConfig("", "enable-argument-filter,record-as-much-as-possible"); |
| 72 EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode()); |
| 73 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 74 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 75 EXPECT_TRUE(config.IsArgumentFilterEnabled()); |
| 76 EXPECT_STREQ("record-as-much-as-possible,enable-argument-filter", |
| 77 config.ToTraceOptionsString().c_str()); |
| 78 |
| 79 config = TraceConfig( |
| 80 "", |
| 81 "enable-systrace,trace-to-console,enable-sampling,enable-argument-filter"); |
| 82 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 83 EXPECT_TRUE(config.IsSamplingEnabled()); |
| 84 EXPECT_TRUE(config.IsSystraceEnabled()); |
| 85 EXPECT_TRUE(config.IsArgumentFilterEnabled()); |
| 86 EXPECT_STREQ( |
| 87 "trace-to-console,enable-sampling,enable-systrace,enable-argument-filter", |
| 88 config.ToTraceOptionsString().c_str()); |
| 89 |
| 90 config = TraceConfig( |
| 91 "", "record-continuously, record-until-full, trace-to-console"); |
| 92 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 93 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 94 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 95 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 96 EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str()); |
| 97 |
| 98 // From TraceRecordMode |
| 99 config = TraceConfig("", RECORD_UNTIL_FULL); |
| 100 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 101 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 102 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 103 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 104 EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str()); |
| 105 |
| 106 config = TraceConfig("", RECORD_CONTINUOUSLY); |
| 107 EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode()); |
| 108 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 109 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 110 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 111 EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str()); |
| 112 |
| 113 config = TraceConfig("", ECHO_TO_CONSOLE); |
| 114 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 115 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 116 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 117 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 118 EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str()); |
| 119 |
| 120 config = TraceConfig("", RECORD_AS_MUCH_AS_POSSIBLE); |
| 121 EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode()); |
| 122 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 123 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 124 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 125 EXPECT_STREQ("record-as-much-as-possible", |
| 126 config.ToTraceOptionsString().c_str()); |
| 127 |
| 128 // From category filter strings |
| 129 config = TraceConfig("-*Debug,-*Test", ""); |
| 130 EXPECT_STREQ("-*Debug,-*Test", config.ToCategoryFilterString().c_str()); |
| 131 |
| 132 config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*", ""); |
| 133 EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*", |
| 134 config.ToCategoryFilterString().c_str()); |
| 135 |
| 136 config = TraceConfig("only_inc_cat", ""); |
| 137 EXPECT_STREQ("only_inc_cat", config.ToCategoryFilterString().c_str()); |
| 138 |
| 139 config = TraceConfig("-only_exc_cat", ""); |
| 140 EXPECT_STREQ("-only_exc_cat", config.ToCategoryFilterString().c_str()); |
| 141 |
| 142 config = TraceConfig("disabled-by-default-cc,-excluded", ""); |
| 143 EXPECT_STREQ("disabled-by-default-cc,-excluded", |
| 144 config.ToCategoryFilterString().c_str()); |
| 145 |
| 146 config = TraceConfig("disabled-by-default-cc,included", ""); |
| 147 EXPECT_STREQ("included,disabled-by-default-cc", |
| 148 config.ToCategoryFilterString().c_str()); |
| 149 |
| 150 config = TraceConfig("DELAY(test.Delay1;16),included", ""); |
| 151 EXPECT_STREQ("included,DELAY(test.Delay1;16)", |
| 152 config.ToCategoryFilterString().c_str()); |
| 153 |
| 154 // From both trace options and category filter strings |
| 155 config = TraceConfig("", ""); |
| 156 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 157 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 158 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 159 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 160 EXPECT_STREQ("", config.ToCategoryFilterString().c_str()); |
| 161 EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str()); |
| 162 |
| 163 config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*", |
| 164 "enable-systrace, trace-to-console, enable-sampling"); |
| 165 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 166 EXPECT_TRUE(config.IsSamplingEnabled()); |
| 167 EXPECT_TRUE(config.IsSystraceEnabled()); |
| 168 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 169 EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*", |
| 170 config.ToCategoryFilterString().c_str()); |
| 171 EXPECT_STREQ("trace-to-console,enable-sampling,enable-systrace", |
| 172 config.ToTraceOptionsString().c_str()); |
| 173 |
| 174 // From both trace options and category filter strings with spaces. |
| 175 config = TraceConfig(" included , -excluded, inc_pattern*, ,-exc_pattern* ", |
| 176 "enable-systrace, ,trace-to-console, enable-sampling "); |
| 177 EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode()); |
| 178 EXPECT_TRUE(config.IsSamplingEnabled()); |
| 179 EXPECT_TRUE(config.IsSystraceEnabled()); |
| 180 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 181 EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*", |
| 182 config.ToCategoryFilterString().c_str()); |
| 183 EXPECT_STREQ("trace-to-console,enable-sampling,enable-systrace", |
| 184 config.ToTraceOptionsString().c_str()); |
| 185 |
| 186 // From category filter string and TraceRecordMode |
| 187 config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*", |
| 188 RECORD_CONTINUOUSLY); |
| 189 EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode()); |
| 190 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 191 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 192 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 193 EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*", |
| 194 config.ToCategoryFilterString().c_str()); |
| 195 EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str()); |
| 196 } |
| 197 |
| 198 TEST(TraceConfigTest, TraceConfigFromInvalidLegacyStrings) { |
| 199 TraceConfig config("", "foo-bar-baz"); |
| 200 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 201 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 202 EXPECT_FALSE(config.IsSystraceEnabled()); |
| 203 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 204 EXPECT_STREQ("", config.ToCategoryFilterString().c_str()); |
| 205 EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str()); |
| 206 |
| 207 config = TraceConfig("arbitrary-category", "foo-bar-baz, enable-systrace"); |
| 208 EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode()); |
| 209 EXPECT_FALSE(config.IsSamplingEnabled()); |
| 210 EXPECT_TRUE(config.IsSystraceEnabled()); |
| 211 EXPECT_FALSE(config.IsArgumentFilterEnabled()); |
| 212 EXPECT_STREQ("arbitrary-category", config.ToCategoryFilterString().c_str()); |
| 213 EXPECT_STREQ("record-until-full,enable-systrace", |
| 214 config.ToTraceOptionsString().c_str()); |
| 215 |
| 216 const char* const configs[] = { |
| 217 "", |
| 218 "DELAY(", |
| 219 "DELAY(;", |
| 220 "DELAY(;)", |
| 221 "DELAY(test.Delay)", |
| 222 "DELAY(test.Delay;)" |
| 223 }; |
| 224 for (size_t i = 0; i < arraysize(configs); i++) { |
| 225 TraceConfig tc(configs[i], ""); |
| 226 EXPECT_EQ(0u, tc.GetSyntheticDelayValues().size()); |
| 227 } |
| 228 } |
| 229 |
| 230 TEST(TraceConfigTest, ConstructDefaultTraceConfig) { |
| 231 // Make sure that upon an empty string, we fall back to the default config. |
| 232 TraceConfig tc; |
| 233 EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str()); |
| 234 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 235 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 236 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 237 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 238 EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str()); |
| 239 |
| 240 EXPECT_FALSE(tc.IsCategoryEnabled("Category1")); |
| 241 EXPECT_FALSE(tc.IsCategoryEnabled("not-excluded-category")); |
| 242 EXPECT_FALSE(tc.IsCategoryEnabled("CategoryTest")); |
| 243 EXPECT_FALSE(tc.IsCategoryEnabled("CategoryDebug")); |
| 244 EXPECT_FALSE(tc.IsCategoryEnabled("disabled-by-default-cc")); |
| 245 |
| 246 EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1")); |
| 247 EXPECT_TRUE(tc.IsCategoryGroupEnabled("not-excluded-category")); |
| 248 EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryTest")); |
| 249 EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryDebug")); |
| 250 EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-cc")); |
| 251 |
| 252 EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,CategoryDebug")); |
| 253 EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryDebug,Category1")); |
| 254 EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryTest,not-excluded-category")); |
| 255 EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryDebug,CategoryTest")); |
| 256 } |
| 257 |
| 258 TEST(TraceConfigTest, TraceConfigFromValidString) { |
| 259 // Using some non-empty config string. |
| 260 const char config_string[] = |
| 261 "{" |
| 262 "\"enable_argument_filter\":true," |
| 263 "\"enable_sampling\":true," |
| 264 "\"enable_systrace\":true," |
| 265 "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"]," |
| 266 "\"included_categories\":[\"included\"," |
| 267 "\"inc_pattern*\"," |
| 268 "\"disabled-by-default-cc\"]," |
| 269 "\"record_mode\":\"record-continuously\"," |
| 270 "\"synthetic_delays\":[\"test.Delay1;16\",\"test.Delay2;32\"]" |
| 271 "}"; |
| 272 TraceConfig tc(config_string); |
| 273 |
| 274 EXPECT_STREQ(config_string, tc.ToString().c_str()); |
| 275 EXPECT_EQ(RECORD_CONTINUOUSLY, tc.GetTraceRecordMode()); |
| 276 EXPECT_TRUE(tc.IsSamplingEnabled()); |
| 277 EXPECT_TRUE(tc.IsSystraceEnabled()); |
| 278 EXPECT_TRUE(tc.IsArgumentFilterEnabled()); |
| 279 EXPECT_STREQ("included,inc_pattern*,disabled-by-default-cc,-excluded," |
| 280 "-exc_pattern*,DELAY(test.Delay1;16),DELAY(test.Delay2;32)", |
| 281 tc.ToCategoryFilterString().c_str()); |
| 282 |
| 283 EXPECT_TRUE(tc.IsCategoryEnabled("included")); |
| 284 EXPECT_TRUE(tc.IsCategoryEnabled("inc_pattern_category")); |
| 285 EXPECT_TRUE(tc.IsCategoryEnabled("disabled-by-default-cc")); |
| 286 EXPECT_FALSE(tc.IsCategoryEnabled("excluded")); |
| 287 EXPECT_FALSE(tc.IsCategoryEnabled("exc_pattern_category")); |
| 288 EXPECT_FALSE(tc.IsCategoryEnabled("disabled-by-default-others")); |
| 289 EXPECT_FALSE(tc.IsCategoryEnabled("not-excluded-nor-included")); |
| 290 |
| 291 EXPECT_TRUE(tc.IsCategoryGroupEnabled("included")); |
| 292 EXPECT_TRUE(tc.IsCategoryGroupEnabled("inc_pattern_category")); |
| 293 EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc")); |
| 294 EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded")); |
| 295 EXPECT_FALSE(tc.IsCategoryGroupEnabled("exc_pattern_category")); |
| 296 EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-others")); |
| 297 EXPECT_FALSE(tc.IsCategoryGroupEnabled("not-excluded-nor-included")); |
| 298 |
| 299 EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,excluded")); |
| 300 EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,exc_pattern_category")); |
| 301 EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,DELAY(test.Delay1;16)")); |
| 302 EXPECT_FALSE(tc.IsCategoryGroupEnabled("DELAY(test.Delay1;16)")); |
| 303 |
| 304 EXPECT_EQ(2u, tc.GetSyntheticDelayValues().size()); |
| 305 EXPECT_STREQ("test.Delay1;16", tc.GetSyntheticDelayValues()[0].c_str()); |
| 306 EXPECT_STREQ("test.Delay2;32", tc.GetSyntheticDelayValues()[1].c_str()); |
| 307 |
| 308 const char config_string_2[] = "{\"included_categories\":[\"*\"]}"; |
| 309 TraceConfig tc2(config_string_2); |
| 310 EXPECT_TRUE(tc2.IsCategoryEnabled("non-disabled-by-default-pattern")); |
| 311 EXPECT_FALSE(tc2.IsCategoryEnabled("disabled-by-default-pattern")); |
| 312 EXPECT_TRUE(tc2.IsCategoryGroupEnabled("non-disabled-by-default-pattern")); |
| 313 EXPECT_FALSE(tc2.IsCategoryGroupEnabled("disabled-by-default-pattern")); |
| 314 |
| 315 // Clear |
| 316 tc.Clear(); |
| 317 EXPECT_STREQ(tc.ToString().c_str(), |
| 318 "{" |
| 319 "\"enable_argument_filter\":false," |
| 320 "\"enable_sampling\":false," |
| 321 "\"enable_systrace\":false," |
| 322 "\"record_mode\":\"record-until-full\"" |
| 323 "}"); |
| 324 } |
| 325 |
| 326 TEST(TraceConfigTest, TraceConfigFromInvalidString) { |
| 327 // The config string needs to be a dictionary correctly formatted as a JSON |
| 328 // string. Otherwise, it will fall back to the default initialization. |
| 329 TraceConfig tc(""); |
| 330 EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str()); |
| 331 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 332 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 333 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 334 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 335 EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str()); |
| 336 |
| 337 tc = TraceConfig("This is an invalid config string."); |
| 338 EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str()); |
| 339 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 340 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 341 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 342 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 343 EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str()); |
| 344 |
| 345 tc = TraceConfig("[\"This\", \"is\", \"not\", \"a\", \"dictionary\"]"); |
| 346 EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str()); |
| 347 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 348 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 349 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 350 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 351 EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str()); |
| 352 |
| 353 tc = TraceConfig("{\"record_mode\": invalid-value-needs-double-quote}"); |
| 354 EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str()); |
| 355 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 356 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 357 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 358 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 359 EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str()); |
| 360 |
| 361 // If the config string a dictionary formatted as a JSON string, it will |
| 362 // initialize TraceConfig with best effort. |
| 363 tc = TraceConfig("{}"); |
| 364 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 365 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 366 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 367 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 368 EXPECT_STREQ("", tc.ToCategoryFilterString().c_str()); |
| 369 |
| 370 tc = TraceConfig("{\"arbitrary-key\":\"arbitrary-value\"}"); |
| 371 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 372 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 373 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 374 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 375 EXPECT_STREQ("", tc.ToCategoryFilterString().c_str()); |
| 376 |
| 377 const char invalid_config_string[] = |
| 378 "{" |
| 379 "\"enable_sampling\":\"true\"," |
| 380 "\"enable_systrace\":1," |
| 381 "\"excluded_categories\":[\"excluded\"]," |
| 382 "\"included_categories\":\"not a list\"," |
| 383 "\"record_mode\":\"arbitrary-mode\"," |
| 384 "\"synthetic_delays\":[\"test.Delay1;16\"," |
| 385 "\"invalid-delay\"," |
| 386 "\"test.Delay2;32\"]" |
| 387 "}"; |
| 388 tc = TraceConfig(invalid_config_string); |
| 389 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 390 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 391 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 392 EXPECT_FALSE(tc.IsArgumentFilterEnabled()); |
| 393 EXPECT_STREQ("-excluded,DELAY(test.Delay1;16),DELAY(test.Delay2;32)", |
| 394 tc.ToCategoryFilterString().c_str()); |
| 395 |
| 396 const char invalid_config_string_2[] = |
| 397 "{" |
| 398 "\"included_categories\":[\"category\",\"disabled-by-default-pattern\"]," |
| 399 "\"excluded_categories\":[\"category\",\"disabled-by-default-pattern\"]" |
| 400 "}"; |
| 401 tc = TraceConfig(invalid_config_string_2); |
| 402 EXPECT_TRUE(tc.IsCategoryEnabled("category")); |
| 403 EXPECT_TRUE(tc.IsCategoryEnabled("disabled-by-default-pattern")); |
| 404 EXPECT_TRUE(tc.IsCategoryGroupEnabled("category")); |
| 405 EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-pattern")); |
| 406 } |
| 407 |
| 408 TEST(TraceConfigTest, MergingTraceConfigs) { |
| 409 // Merge |
| 410 TraceConfig tc; |
| 411 TraceConfig tc2("included,-excluded,inc_pattern*,-exc_pattern*", ""); |
| 412 tc.Merge(tc2); |
| 413 EXPECT_STREQ("{" |
| 414 "\"enable_argument_filter\":false," |
| 415 "\"enable_sampling\":false," |
| 416 "\"enable_systrace\":false," |
| 417 "\"excluded_categories\":[" |
| 418 "\"*Debug\",\"*Test\",\"excluded\",\"exc_pattern*\"" |
| 419 "]," |
| 420 "\"record_mode\":\"record-until-full\"" |
| 421 "}", |
| 422 tc.ToString().c_str()); |
| 423 |
| 424 tc = TraceConfig("DELAY(test.Delay1;16)", ""); |
| 425 tc2 = TraceConfig("DELAY(test.Delay2;32)", ""); |
| 426 tc.Merge(tc2); |
| 427 EXPECT_EQ(2u, tc.GetSyntheticDelayValues().size()); |
| 428 EXPECT_STREQ("test.Delay1;16", tc.GetSyntheticDelayValues()[0].c_str()); |
| 429 EXPECT_STREQ("test.Delay2;32", tc.GetSyntheticDelayValues()[1].c_str()); |
| 430 } |
| 431 |
| 432 TEST(TraceConfigTest, IsCategoryGroupEnabled) { |
| 433 // Enabling a disabled- category does not require all categories to be traced |
| 434 // to be included. |
| 435 TraceConfig tc("disabled-by-default-cc,-excluded", ""); |
| 436 EXPECT_STREQ("disabled-by-default-cc,-excluded", |
| 437 tc.ToCategoryFilterString().c_str()); |
| 438 EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc")); |
| 439 EXPECT_TRUE(tc.IsCategoryGroupEnabled("some_other_group")); |
| 440 EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded")); |
| 441 |
| 442 // Enabled a disabled- category and also including makes all categories to |
| 443 // be traced require including. |
| 444 tc = TraceConfig("disabled-by-default-cc,included", ""); |
| 445 EXPECT_STREQ("included,disabled-by-default-cc", |
| 446 tc.ToCategoryFilterString().c_str()); |
| 447 EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc")); |
| 448 EXPECT_TRUE(tc.IsCategoryGroupEnabled("included")); |
| 449 EXPECT_FALSE(tc.IsCategoryGroupEnabled("other_included")); |
| 450 } |
| 451 |
| 452 TEST(TraceConfigTest, IsEmptyOrContainsLeadingOrTrailingWhitespace) { |
| 453 // Test that IsEmptyOrContainsLeadingOrTrailingWhitespace actually catches |
| 454 // categories that are explicitly forbidden. |
| 455 // This method is called in a DCHECK to assert that we don't have these types |
| 456 // of strings as categories. |
| 457 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 458 " bad_category ")); |
| 459 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 460 " bad_category")); |
| 461 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 462 "bad_category ")); |
| 463 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 464 " bad_category")); |
| 465 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 466 "bad_category ")); |
| 467 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 468 " bad_category ")); |
| 469 EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 470 "")); |
| 471 EXPECT_FALSE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace( |
| 472 "good_category")); |
| 473 } |
| 474 |
| 475 TEST(TraceConfigTest, SetTraceOptionValues) { |
| 476 TraceConfig tc; |
| 477 EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode()); |
| 478 EXPECT_FALSE(tc.IsSamplingEnabled()); |
| 479 EXPECT_FALSE(tc.IsSystraceEnabled()); |
| 480 |
| 481 tc.SetTraceRecordMode(RECORD_AS_MUCH_AS_POSSIBLE); |
| 482 EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, tc.GetTraceRecordMode()); |
| 483 |
| 484 tc.EnableSampling(); |
| 485 EXPECT_TRUE(tc.IsSamplingEnabled()); |
| 486 |
| 487 tc.EnableSystrace(); |
| 488 EXPECT_TRUE(tc.IsSystraceEnabled()); |
| 489 } |
| 490 |
| 491 } // namespace trace_event |
| 492 } // namespace base |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1180693002:
Update from https://crrev.com/333737 (Closed)
Base URL: https://github.com/domokit/mojo.git@master