base/trace_event/trace_config_unittest.cc

   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