add classes trace_analyzer::Query and TraceAnalyzer to make it easy to search through trace data

base/test/trace_event_analyzer_unittest.cc

Index: base/test/trace_event_analyzer_unittest.cc
diff --git a/base/test/trace_event_analyzer_unittest.cc b/base/test/trace_event_analyzer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fb36cb13cbf3527e895bf3b9a2071e179b453a65
--- /dev/null
+++ b/base/test/trace_event_analyzer_unittest.cc
@@ -0,0 +1,238 @@
+// Copyright (c) 2011 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 "base/bind.h"
+#include "base/test/trace_event_analyzer.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace trace_analyzer {
+
+namespace {
+
+class TraceEventAnalyzerTest : public testing::Test {
+ public:
+  void ManualSetUp();
+  void OnTraceDataCollected(
+      scoped_refptr<base::debug::TraceLog::RefCountedString> json_events_str);
+
+  std::string trace_string_;
+};
+
+void TraceEventAnalyzerTest::ManualSetUp() {
+  base::debug::TraceLog::Resurrect();
+  base::debug::TraceLog* tracelog = base::debug::TraceLog::GetInstance();
+  ASSERT_TRUE(tracelog);
+  tracelog->SetOutputCallback(
+    base::Bind(&TraceEventAnalyzerTest::OnTraceDataCollected,
+               base::Unretained(this)));
+}
+
+void TraceEventAnalyzerTest::OnTraceDataCollected(
+    scoped_refptr<base::debug::TraceLog::RefCountedString> json_events_str) {
+  trace_string_ = json_events_str->data;
+}
+
+}  // namespace
+
+// Test that the TraceAnalyzer works.
+TEST_F(TraceEventAnalyzerTest, TraceAnalyzerBasic) {
+  using namespace trace_analyzer;
+  ManualSetUp();
+
+  base::debug::TraceLog::GetInstance()->SetEnabled(true);
+  {
+    TRACE_EVENT_END0("cat3", "name7");
+    TRACE_EVENT2("cat1", "name1", "arg1", 1111, "arg2", "string1");
+    {
+      TRACE_EVENT2("cat2", "name2", "arg1", 2222, "arg2", "string2");
+      TRACE_EVENT_INSTANT1("cat1", "name3", "arg1", 3333);
+      base::PlatformThread::Sleep(200);
+      TRACE_EVENT0("cat2", "name6");
+    }
+    TRACE_EVENT_INSTANT1("cat2", "name4", "arg1", 4444);
+    TRACE_EVENT_INSTANT1("cat2", "name5", "arg1", 1111);
+    TRACE_EVENT_BEGIN0("cat3", "name7");
+    TRACE_EVENT_INSTANT2("cat4", "math1", "a", 10, "b", 5);
+    TRACE_EVENT_INSTANT2("cat4", "math2", "a", 10, "b", 10);
+  }
+  base::debug::TraceLog::GetInstance()->SetEnabled(false);
+
+  const TraceEvent* event = NULL;
+  TraceAnalyzer* analyzer = TraceAnalyzer::Create(trace_string_);
+  ASSERT_TRUE(!!analyzer);
+  analyzer->AssociateBeginEndEvents();
+
+  TraceAnalyzer::TraceEventVector found;
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat1", &found);
+  EXPECT_EQ(3u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat1" &&
+                      Query(EVENT_ARG, "arg1") == 1111, &found);
+  ASSERT_EQ(1u, found.size());
+  EXPECT_STREQ("name1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg1") == 1111 ||
+                      Query(EVENT_ARG, "arg1") == 2222, &found);
+  EXPECT_EQ(3u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg1") == 1111 &&
+                      Query(EVENT_NAME) != "name1", &found);
+  ASSERT_EQ(1u, found.size());
+  EXPECT_STREQ("name5", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg1") == 1111 &&
+                      !(Query(EVENT_NAME) != "name1"), &found);
+  ASSERT_EQ(1u, found.size());
+  EXPECT_STREQ("name1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query::MatchBeginWithEnd() &&
+                      Query(EVENT_DURATION) > 180000 &&
+                      (Query(EVENT_CATEGORY) == "cat1" ||
+                       Query(EVENT_CATEGORY) == "cat2" ||
+                       Query(EVENT_CATEGORY) == "cat3"), &found);
+  EXPECT_EQ(2u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg1") <= 3333, &found);
+  EXPECT_EQ(4u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg1") >= 3333, &found);
+  EXPECT_EQ(2u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_HAS_ARG, "arg1"), &found);
+  EXPECT_EQ(5u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg2") == "string1", &found);
+  ASSERT_EQ(1u, found.size());
+  EXPECT_STREQ("name1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "arg2") == Query::Pattern("string?"),
+                      &found);
+  EXPECT_EQ(2u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == Query::Pattern("cat?") &&
+                      Query(EVENT_NAME) != Query::Pattern("*"),
+                      &found);
+  EXPECT_EQ(0u, found.size());
+
+  analyzer->FindEvents(!Query(EVENT_HAS_OTHER) &&
+                      Query(EVENT_CATEGORY) == "cat2", &found);
+  EXPECT_EQ(2u, found.size());
+
+  event = analyzer->FindOneEvent(Query(OTHER_ARG, "arg1") == 1111);
+  ASSERT_TRUE(event);
+  EXPECT_STREQ("name1", event->name.c_str());
+
+  // Verify that matching END..BEGIN does not get associated.
+  ASSERT_TRUE(!analyzer->FindOneEvent(Query::MatchBeginName("name7")));
+
+  ASSERT_TRUE(!analyzer->FindOneEvent(Query(EVENT_ARG, "arg1") < 1111));
+
+  // Verify that arithmetic operators function:
+
+  analyzer->FindEvents(Query(EVENT_ARG, "a") + Query(EVENT_ARG, "b") == 20,
+                      &found);
+  EXPECT_EQ(1u, found.size());
+  EXPECT_STREQ("math2", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "a") - Query(EVENT_ARG, "b") == 5,
+                      &found);
+  EXPECT_EQ(1u, found.size());
+  EXPECT_STREQ("math1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "a") * Query(EVENT_ARG, "b") == 50,
+                      &found);
+  EXPECT_EQ(1u, found.size());
+  EXPECT_STREQ("math1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "a") / Query(EVENT_ARG, "b") == 2,
+                      &found);
+  EXPECT_EQ(1u, found.size());
+  EXPECT_STREQ("math1", found.front()->name.c_str());
+
+  analyzer->FindEvents(Query(EVENT_ARG, "a") % Query(EVENT_ARG, "b") == 0,
+                      &found);
+  EXPECT_EQ(2u, found.size());
+
+  analyzer->FindEvents(-Query(EVENT_ARG, "b") == -10, &found);
+  EXPECT_EQ(1u, found.size());
+  EXPECT_STREQ("math2", found.front()->name.c_str());
+}
+
+// Test that the TraceAnalyzer custom associations work.
+TEST_F(TraceEventAnalyzerTest, TraceAnalyzerAssociations) {
+  using namespace trace_analyzer;
+  ManualSetUp();
+
+  base::debug::TraceLog::GetInstance()->SetEnabled(true);
+  {
+    TRACE_EVENT_INSTANT1("cat1", "end", "id", 1);
+    TRACE_EVENT_INSTANT1("cat2", "begin", "id", 2);
+    TRACE_EVENT_INSTANT1("cat3", "begin", "id", 3);
+    TRACE_EVENT_INSTANT1("cat4", "end", "id", 2);
+    TRACE_EVENT_INSTANT1("cat5", "end", "id", 3);
+    TRACE_EVENT_INSTANT1("cat6", "begin", "id", 1);
+  }
+  base::debug::TraceLog::GetInstance()->SetEnabled(false);
+
+  TraceAnalyzer* analyzer = TraceAnalyzer::Create(trace_string_);
+  ASSERT_TRUE(!!analyzer);
+
+  Query begin(Query(EVENT_NAME) == "begin");
+  Query end(Query(EVENT_NAME) == "end");
+  Query match(Query(EVENT_ARG, "id") == Query(OTHER_ARG, "id"));
+  analyzer->AssociateEvents(begin, end, match);
+
+  TraceAnalyzer::TraceEventVector found;
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat1" &&
+                      Query(EVENT_HAS_OTHER), &found);
+  EXPECT_EQ(0u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat1" &&
+                      !Query(EVENT_HAS_OTHER), &found);
+  EXPECT_EQ(1u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat6" &&
+                      !Query(EVENT_HAS_OTHER), &found);
+  EXPECT_EQ(1u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat2" &&
+                      Query(OTHER_CATEGORY) == "cat4", &found);
+  EXPECT_EQ(1u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat4" &&
+                      Query(OTHER_CATEGORY) == "cat2", &found);
+  EXPECT_EQ(1u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat3" &&
+                      Query(OTHER_CATEGORY) == "cat5", &found);
+  EXPECT_EQ(1u, found.size());
+
+  analyzer->FindEvents(Query(EVENT_CATEGORY) == "cat5" &&
+                      Query(OTHER_CATEGORY) == "cat3", &found);
+  EXPECT_EQ(1u, found.size());
+
+  // Verify that literals and types are properly casted.
+
+  // Since these queries don't refer to the event data, the dummy event below
+  // will never be accessed.
+  TraceEvent dummy;
+  char char_num = 5;
+  short short_num = -5;
+  EXPECT_TRUE((Query(5.0) == char_num).Evaluate(dummy));
+  EXPECT_TRUE((Query(-5.0) == short_num).Evaluate(dummy));
+  EXPECT_TRUE((Query(1.0) == 1u).Evaluate(dummy));
+  EXPECT_TRUE((Query(1.0) == 1).Evaluate(dummy));
+  EXPECT_TRUE((Query(-1.0) == -1).Evaluate(dummy));
+  EXPECT_TRUE((Query(1.0) == 1.0f).Evaluate(dummy));
+  EXPECT_TRUE((Query(true) == 1).Evaluate(dummy));
+  EXPECT_TRUE((Query(false) == 0).Evaluate(dummy));
+  EXPECT_TRUE((Query(true) == 1.0f).Evaluate(dummy));
+  EXPECT_TRUE((Query(false) == 0.0f).Evaluate(dummy));
+}
+
+
+}  // namespace trace_analyzer
+