[Startup Tracing] The TraceConfig class [STALE]

base/trace_event/trace_event_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <math.h>
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 3062 matching lines @@
         TraceOptions new_options;
         EXPECT_TRUE(new_options.SetFromString(original_option.ToString()));
         EXPECT_EQ(original_option.record_mode, new_options.record_mode);
         EXPECT_EQ(original_option.enable_sampling, new_options.enable_sampling);
         EXPECT_EQ(original_option.enable_systrace, new_options.enable_systrace);
       }
     }
   }
 }
 
+TEST(TraceConfigTest, TraceConfigFromAndToString) {
+  // From and to trace options strings
+  TraceConfig config = TraceConfig("", "record-until-full");
+  EXPECT_EQ(RECORD_UNTIL_FULL, config.record_mode_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "record-continuously");
+  EXPECT_EQ(RECORD_CONTINUOUSLY, config.record_mode_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "trace-to-console");
+  EXPECT_EQ(ECHO_TO_CONSOLE, config.record_mode_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "record-as-much-as-possible");
+  EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.record_mode_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_STREQ("record-as-much-as-possible",
+               config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "record-until-full, enable-sampling");
+  EXPECT_EQ(RECORD_UNTIL_FULL, config.record_mode_);
+  EXPECT_TRUE(config.enable_sampling_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_STREQ("record-until-full,enable-sampling",
+               config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "enable-systrace, record-continuously");
+  EXPECT_EQ(RECORD_CONTINUOUSLY, config.record_mode_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_TRUE(config.enable_systrace_);
+  EXPECT_STREQ("record-continuously,enable-systrace",
+               config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("",
+                       "enable-systrace, trace-to-console, enable-sampling");
+  EXPECT_EQ(ECHO_TO_CONSOLE, config.record_mode_);
+  EXPECT_TRUE(config.enable_sampling_);
+  EXPECT_TRUE(config.enable_systrace_);
+  EXPECT_STREQ("trace-to-console,enable-sampling,enable-systrace",
+               config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig(
+    "", "record-continuously, record-until-full, trace-to-console");
+  EXPECT_EQ(ECHO_TO_CONSOLE, config.record_mode_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("", "foo-bar-baz");

[nednguyen, 2015/05/11 17:59:28]

I would move these invalid trace option cases to a separate test. Few other
cases to test are:
valid category, invalid trace option
invalid category, valid trace option
invalid category, invalid trace option

[Zhen Wang, 2015/05/13 00:01:11]

Added TraceConfigFromInvalidLegacyString.

There is no actual invalid category. Category name can be specified as arbitrary
string.

+  EXPECT_EQ(RECORD_UNTIL_FULL, config.record_mode_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
+
+  // From and to category filter strings
+  config = TraceConfig("-*Debug,-*Test", "");
+  EXPECT_STREQ("-*Debug,-*Test", config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*", "");
+  EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
+               config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("only_inc_cat", "");
+  EXPECT_STREQ("only_inc_cat", config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("-only_exc_cat", "");
+  EXPECT_STREQ("-only_exc_cat", config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("disabled-by-default-cc,-excluded", "");
+  EXPECT_STREQ("disabled-by-default-cc,-excluded",
+               config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("disabled-by-default-cc,included", "");
+  EXPECT_STREQ("included,disabled-by-default-cc",
+               config.ToCategoryFilterString().c_str());
+
+  config = TraceConfig("DELAY(test.Delay1;16),included", "");
+  EXPECT_STREQ("included,DELAY(test.Delay1;16)",
+               config.ToCategoryFilterString().c_str());
+
+  // From and to both trace options and category filter strings
+  config = TraceConfig("", "");
+  EXPECT_EQ(RECORD_UNTIL_FULL, config.record_mode_);
+  EXPECT_FALSE(config.enable_systrace_);
+  EXPECT_FALSE(config.enable_sampling_);
+  EXPECT_STREQ("-*Debug,-*Test", config.ToCategoryFilterString().c_str());
+  EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
+
+  config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*",
+                       "enable-systrace, trace-to-console, enable-sampling");
+  EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
+               config.ToCategoryFilterString().c_str());
+  EXPECT_STREQ("trace-to-console,enable-sampling,enable-systrace",
+               config.ToTraceOptionsString().c_str());
+}
+
+TEST(TraceConfigTest, TraceConfigFromAndToLegacyFormat) {
+  std::string filter_string = "included,-excluded,inc_pattern*,-exc_pattern*";
+  std::string options_string =
+    "enable-systrace, trace-to-console, enable-sampling";
+  TraceConfig tc = TraceConfig(filter_string, options_string);
+  CategoryFilter cf;
+  TraceOptions to;
+  tc.ToCategoryFilter(cf);
+  tc.ToTraceOptions(to);
+
+  CategoryFilter cf2 = CategoryFilter(filter_string);
+  TraceOptions to2;
+  to2.SetFromString(options_string);
+  TraceConfig tc2 = TraceConfig(cf2, to2);
+
+  EXPECT_STREQ(cf.ToString().c_str(), cf2.ToString().c_str());
+  EXPECT_STREQ(to.ToString().c_str(), to2.ToString().c_str());
+  EXPECT_STREQ(tc.ToString().c_str(), tc2.ToString().c_str());
+}
+
+TEST(TraceConfigTest, TraceConfig) {

[nednguyen, 2015/05/11 17:59:28]

This test should also split into multiple ones, each focuses on testing a single
aspect of TraceConfig. 

TEST(TraceConfigTest, ConstructDefaultTraceConfig) {
}

TEST(TraceConfigTest, TraceConfigFromValidString) {
}

TEST(TraceConfigTest, TraceConfigFromInvalidString) {
}

TEST(TraceConfigTest, MergingTraceConfigs) {
}

[Zhen Wang, 2015/05/13 00:01:11]

Done.

+  // Using the default trace config.
+  TraceConfig tc = TraceConfig(TraceConfig::kDefaultTraceConfigString);
+
+  EXPECT_STREQ(TraceConfig::kDefaultTraceConfigString, tc.ToString().c_str());
+  EXPECT_TRUE(tc.record_mode_ == RECORD_UNTIL_FULL);
+  EXPECT_FALSE(tc.enable_sampling_);
+  EXPECT_FALSE(tc.enable_systrace_);
+  EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str());
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("not-excluded-category"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-category"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,CategoryDebug"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryDebug,Category1"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryTest,Category2"));
+
+  // Make sure that upon an empty string, we fall back to the default config.
+  tc = TraceConfig();
+  EXPECT_STREQ(TraceConfig::kDefaultTraceConfigString, tc.ToString().c_str());
+  EXPECT_TRUE(tc.record_mode_ == RECORD_UNTIL_FULL);
+  EXPECT_FALSE(tc.enable_sampling_);
+  EXPECT_FALSE(tc.enable_systrace_);
+  EXPECT_STREQ("-*Debug,-*Test", tc.ToCategoryFilterString().c_str());
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("not-excluded-category"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,CategoryDebug"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryDebug,Category1"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryTest,Category2"));
+
+  // Using an arbitrary non-empty config string.
+  char config_string[] =
+    "{"
+      "\"enable_sampling\":true,"
+      "\"enable_systrace\":true,"
+      "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
+      "\"included_categories\":[\"included\",\"inc_pattern*\"],"
+      "\"record_mode\":\"record-continuously\","
+      "\"synthetic_delays\":[\"test.Delay1;16\"]"
+    "}";
+  tc = TraceConfig(config_string);
+  EXPECT_STREQ(config_string, tc.ToString().c_str());
+  EXPECT_TRUE(tc.record_mode_ == RECORD_CONTINUOUSLY);
+  EXPECT_TRUE(tc.enable_sampling_);
+  EXPECT_TRUE(tc.enable_systrace_);
+  EXPECT_STREQ(
+    "included,inc_pattern*,-excluded,-exc_pattern*,DELAY(test.Delay1;16)",
+    tc.ToCategoryFilterString().c_str());
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("inc_pattern_category"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("exc_pattern_category"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("not-excluded-nor-included"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("Category1,CategoryDebug"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryDebug,Category1"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryTest,Category2"));

[nednguyen, 2015/05/11 17:59:28]

what about synthetic delay values?

[Zhen Wang, 2015/05/13 00:01:11]

Synthetic delay values are not considered in IsCategoryGroupEnabled

[nednguyen, 2015/05/13 18:16:31]

I mean we should also add test for synthetic delay.

[Zhen Wang, 2015/05/13 20:59:16]

This test includes "\"synthetic_delays\":[\"test.Delay1;16\"]". I also add a
invalid test for synthetic delays in TraceConfigFromInvalidString.

+
+  // Clear
+  tc.Clear();
+  EXPECT_STREQ(tc.ToString().c_str(),
+               "{"
+                 "\"enable_sampling\":false,"
+                 "\"enable_systrace\":false,"
+                 "\"record_mode\":\"record-until-full\""
+               "}");
+
+  // Merge
+  tc = TraceConfig();
+  TraceConfig tc2 = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*",
+                                "");
+  tc.Merge(tc2);
+  EXPECT_STREQ("{"
+                 "\"enable_sampling\":false,"
+                 "\"enable_systrace\":false,"
+                 "\"excluded_categories\":["
+                   "\"*Debug\",\"*Test\",\"excluded\",\"exc_pattern*\""
+                 "],"
+                 "\"record_mode\":\"record-until-full\""
+               "}",
+               tc.ToString().c_str());
+
+  // Enabling a disabled- category does not require all categories to be traced
+  // to be included.
+  tc = TraceConfig("disabled-by-default-cc,-excluded", "");
+  EXPECT_STREQ("disabled-by-default-cc,-excluded",
+               tc.ToCategoryFilterString().c_str());
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("some_other_group"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded"));
+
+  // Enabled a disabled- category and also including makes all categories to
+  // be traced require including.
+  tc = TraceConfig("disabled-by-default-cc,included", "");
+  EXPECT_STREQ("included,disabled-by-default-cc",
+               tc.ToCategoryFilterString().c_str());
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
+  EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
+  EXPECT_FALSE(tc.IsCategoryGroupEnabled("other_included"));
+
+  // Test that IsEmptyOrContainsLeadingOrTrailingWhitespace actually catches
+  // categories that are explicitly forbidden.
+  // This method is called in a DCHECK to assert that we don't have these types
+  // of strings as categories.
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      " bad_category "));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      " bad_category"));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      "bad_category "));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      "   bad_category"));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      "bad_category   "));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      "   bad_category   "));
+  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      ""));
+  EXPECT_FALSE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
+      "good_category"));
+}
+
 }  // namespace trace_event
 }  // namespace base