Add searching features to new TraceEventVector class for tests.

base/test/trace_event_analyzer_unittest.cc

 // 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 {
@@ skipping 47 matching lines @@
 
   // Create an empty JSON event string:
   buffer_.Start();
   buffer_.Finish();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   // Search for all events and verify that nothing is returned.
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
   analyzer->FindEvents(Query::Bool(true), &found);
   EXPECT_EQ(0u, found.size());
 }
 
 TEST_F(TraceEventAnalyzerTest, TraceEvent) {
   using namespace trace_analyzer;
   ManualSetUp();
 
   int int_num = 2;
   double double_num = 3.5;
@@ skipping 135 matching lines @@
     TRACE_EVENT_INSTANT1("cat1", "name2", "num", 2);
     TRACE_EVENT_INSTANT1("cat2", "name3", "num", 3);
     TRACE_EVENT_INSTANT1("cat2", "name4", "num", 4);
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(!!analyzer.get());
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
 
   // ==
 
   analyzer->FindEvents(Query(EVENT_CATEGORY) == Query::String("cat1"), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
   EXPECT_STREQ("name2", found[1]->name.c_str());
 
   analyzer->FindEvents(Query(EVENT_ARG, "num") == Query::Int(2), &found);
   ASSERT_EQ(1u, found.size());
@@ skipping 66 matching lines @@
     // Extra events that never match, for noise:
     TRACE_EVENT_INSTANT2("noise", "math3", "a", 1,  "b", 3);
     TRACE_EVENT_INSTANT2("noise", "math4", "c", 10, "d", 5);
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
 
   // Verify that arithmetic operators function:
 
   // +
   analyzer->FindEvents(Query(EVENT_ARG, "a") + Query(EVENT_ARG, "b") ==
                        Query::Int(20), &found);
   EXPECT_EQ(1u, found.size());
   EXPECT_STREQ("math2", found.front()->name.c_str());
 
   // -
@@ skipping 35 matching lines @@
     TRACE_EVENT_INSTANT0("cat1", "name2");
     TRACE_EVENT_INSTANT0("cat1", "no match");
     TRACE_EVENT_INSTANT0("cat1", "name3x");
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
 
   analyzer->FindEvents(Query(EVENT_NAME) == Query::Pattern("name?"), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
   EXPECT_STREQ("name2", found[1]->name.c_str());
 
   analyzer->FindEvents(Query(EVENT_NAME) == Query::Pattern("name*"), &found);
   ASSERT_EQ(3u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
   EXPECT_STREQ("name2", found[1]->name.c_str());
@@ skipping 25 matching lines @@
       TRACE_EVENT0("cat2", "name5"); // not found (duration too short)
     }
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
   analyzer->FindEvents(Query::MatchBeginWithEnd() &&
                       Query(EVENT_DURATION) > Query::Int(duration_cutoff_us) &&
                       (Query(EVENT_CATEGORY) == Query::String("cat1") ||
                        Query(EVENT_CATEGORY) == Query::String("cat2") ||
                        Query(EVENT_CATEGORY) == Query::String("cat3")), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STREQ("name1", found[0]->name.c_str());
   EXPECT_STREQ("name3", found[1]->name.c_str());
 }
 
 // Test AssociateBeginEndEvents
 TEST_F(TraceEventAnalyzerTest, BeginEndAssocations) {
   using namespace trace_analyzer;
   ManualSetUp();
 
   BeginTracing();
   {
     TRACE_EVENT_END0("cat1", "name1"); // does not match out of order begin
     TRACE_EVENT0("cat1", "name2");
     TRACE_EVENT_INSTANT0("cat1", "name3");
     TRACE_EVENT_BEGIN0("cat1", "name1");
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
   analyzer->FindEvents(Query::MatchBeginWithEnd(), &found);
   ASSERT_EQ(1u, found.size());
   EXPECT_STREQ("name2", found[0]->name.c_str());
 }
 
+// Test MergeAssociatedEventArgs
+TEST_F(TraceEventAnalyzerTest, MergeAssociatedEventArgs) {
+  using namespace trace_analyzer;
+  ManualSetUp();
+
+  const char* arg_string = "arg_string";
+  BeginTracing();
+  {
+    TRACE_EVENT1("cat1", "name1", "arg", arg_string);
+  }
+  EndTracing();
+
+  scoped_ptr<TraceAnalyzer>
+      analyzer(TraceAnalyzer::Create(output_.json_output));
+  ASSERT_TRUE(analyzer.get());
+  analyzer->AssociateBeginEndEvents();
+
+  TraceEventVector found;
+  analyzer->FindEvents(Query(EVENT_NAME) == Query::String("name1") &&
+      Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_END), &found);
+  ASSERT_EQ(1u, found.size());
+  std::string arg_actual;
+  EXPECT_FALSE(found[0]->GetArgAsString("arg", &arg_actual));
+
+  analyzer->MergeAssociatedEventArgs();
+  EXPECT_TRUE(found[0]->GetArgAsString("arg", &arg_actual));
+  EXPECT_STREQ(arg_string, arg_actual.c_str());
+}
+
 // Test AssociateStartFinishEvents
 TEST_F(TraceEventAnalyzerTest, StartFinishAssocations) {
   using namespace trace_analyzer;
   ManualSetUp();
 
   BeginTracing();
   {
     TRACE_EVENT_FINISH0("cat1", "name1", 0xA); // does not match / out of order
     TRACE_EVENT_START0("cat1", "name1", 0xB);
     TRACE_EVENT_START0("cat1", "name1", 0xC);
     TRACE_EVENT_INSTANT0("cat1", "name1"); // noise
     TRACE_EVENT0("cat1", "name1"); // noise
     TRACE_EVENT_FINISH0("cat1", "name1", 0xB);
     TRACE_EVENT_FINISH0("cat1", "name1", 0xC);
     TRACE_EVENT_START0("cat1", "name1", 0xA); // does not match / out of order
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateStartFinishEvents();
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
   analyzer->FindEvents(Query::MatchStartWithFinish(), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STRCASEEQ("B", found[0]->id.c_str());
   EXPECT_STRCASEEQ("C", found[1]->id.c_str());
 }
 
 // Test that the TraceAnalyzer custom associations work.
 TEST_F(TraceEventAnalyzerTest, CustomAssociations) {
   using namespace trace_analyzer;
   ManualSetUp();
@@ skipping 14 matching lines @@
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   // begin, end, and match queries to find proper begin/end pairs.
   Query begin(Query(EVENT_NAME) == Query::String("begin"));
   Query end(Query(EVENT_NAME) == Query::String("end"));
   Query match(Query(EVENT_ARG, "id") == Query(OTHER_ARG, "id"));
   analyzer->AssociateEvents(begin, end, match);
 
-  TraceAnalyzer::TraceEventVector found;
+  TraceEventVector found;
 
   // cat1 has no other_event.
   analyzer->FindEvents(Query(EVENT_CATEGORY) == Query::String("cat1") &&
                        Query(EVENT_HAS_OTHER), &found);
   EXPECT_EQ(0u, found.size());
 
   // cat1 has no other_event.
   analyzer->FindEvents(Query(EVENT_CATEGORY) == Query::String("cat1") &&
                        !Query(EVENT_HAS_OTHER), &found);
   EXPECT_EQ(1u, found.size());
@@ skipping 45 matching lines @@
   EXPECT_TRUE((Query::Bool(true) == Query::Double(1.0f)).Evaluate(dummy));
   EXPECT_TRUE((Query::Bool(false) == Query::Double(0.0f)).Evaluate(dummy));
 }
 
 // Test GetRateStats.
 TEST_F(TraceEventAnalyzerTest, RateStats) {
   using namespace trace_analyzer;
 
   std::vector<TraceEvent> events;
   events.reserve(100);
-  TraceAnalyzer::TraceEventVector event_ptrs;
+  TraceEventVector event_ptrs;
   TraceEvent event;
   event.timestamp = 0.0;
   double little_delta = 1.0;
   double big_delta = 10.0;
-  TraceAnalyzer::Stats stats;
+  RateStats stats;
 
   for (int i = 0; i < 10; ++i) {
     event.timestamp += little_delta;
     events.push_back(event);
     event_ptrs.push_back(&events.back());
   }
 
-  ASSERT_TRUE(TraceAnalyzer::GetRateStats(event_ptrs, &stats));
+  ASSERT_TRUE(GetRateStats(event_ptrs, &stats));
   EXPECT_EQ(little_delta, stats.mean_us);
   EXPECT_EQ(little_delta, stats.min_us);
   EXPECT_EQ(little_delta, stats.max_us);
   EXPECT_EQ(0.0, stats.standard_deviation_us);
 
   event.timestamp += big_delta;
   events.push_back(event);
   event_ptrs.push_back(&events.back());
 
-  ASSERT_TRUE(TraceAnalyzer::GetRateStats(event_ptrs, &stats));
+  ASSERT_TRUE(GetRateStats(event_ptrs, &stats));
   EXPECT_LT(little_delta, stats.mean_us);
   EXPECT_EQ(little_delta, stats.min_us);
   EXPECT_EQ(big_delta, stats.max_us);
   EXPECT_LT(0.0, stats.standard_deviation_us);
 
-  TraceAnalyzer::TraceEventVector few_event_ptrs;
+  TraceEventVector few_event_ptrs;
   few_event_ptrs.push_back(&event);
   few_event_ptrs.push_back(&event);
-  ASSERT_FALSE(TraceAnalyzer::GetRateStats(few_event_ptrs, &stats));
+  ASSERT_FALSE(GetRateStats(few_event_ptrs, &stats));
   few_event_ptrs.push_back(&event);
-  ASSERT_TRUE(TraceAnalyzer::GetRateStats(few_event_ptrs, &stats));
+  ASSERT_TRUE(GetRateStats(few_event_ptrs, &stats));
+}
+
+// Test FindFirstOf and FindLastOf.
+TEST_F(TraceEventAnalyzerTest, FindOf) {
+  using namespace trace_analyzer;
+
+  size_t num_events = 100;
+  size_t index = 0;
+  TraceEventVector event_ptrs;
+  EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(true), 0, &index));
+  EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(true), 10, &index));
+  EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(true), 0, &index));
+  EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(true), 10, &index));
+
+  std::vector<TraceEvent> events;
+  events.resize(num_events);
+  for (size_t i = 0; i < events.size(); ++i)
+    event_ptrs.push_back(&events[i]);
+  size_t bam_index = num_events/2;
+  events[bam_index].name = "bam";
+  Query query_bam = Query(EVENT_NAME) == Query::String(events[bam_index].name);
+
+  // FindFirstOf
+  EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(false), 0, &index));
+  EXPECT_TRUE(FindFirstOf(event_ptrs, Query::Bool(true), 0, &index));
+  EXPECT_EQ(0u, index);
+  EXPECT_TRUE(FindFirstOf(event_ptrs, Query::Bool(true), 5, &index));
+  EXPECT_EQ(5u, index);
+
+  EXPECT_FALSE(FindFirstOf(event_ptrs, query_bam, bam_index + 1, &index));
+  EXPECT_TRUE(FindFirstOf(event_ptrs, query_bam, 0, &index));
+  EXPECT_EQ(bam_index, index);
+  EXPECT_TRUE(FindFirstOf(event_ptrs, query_bam, bam_index, &index));
+  EXPECT_EQ(bam_index, index);
+
+  // FindLastOf
+  EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(false), 1000, &index));
+  EXPECT_TRUE(FindLastOf(event_ptrs, Query::Bool(true), 1000, &index));
+  EXPECT_EQ(num_events - 1, index);
+  EXPECT_TRUE(FindLastOf(event_ptrs, Query::Bool(true), num_events - 5,
+                         &index));
+  EXPECT_EQ(num_events - 5, index);
+
+  EXPECT_FALSE(FindLastOf(event_ptrs, query_bam, bam_index - 1, &index));
+  EXPECT_TRUE(FindLastOf(event_ptrs, query_bam, num_events, &index));
+  EXPECT_EQ(bam_index, index);
+  EXPECT_TRUE(FindLastOf(event_ptrs, query_bam, bam_index, &index));
+  EXPECT_EQ(bam_index, index);
+}
+
+// Test FindClosest.
+TEST_F(TraceEventAnalyzerTest, FindClosest) {
+  using namespace trace_analyzer;
+
+  size_t index_1 = 0;
+  size_t index_2 = 0;
+  TraceEventVector event_ptrs;
+  EXPECT_FALSE(FindClosest(event_ptrs, Query::Bool(true), 0,
+                           &index_1, &index_2));
+
+  size_t num_events = 5;
+  std::vector<TraceEvent> events;
+  events.resize(num_events);
+  for (size_t i = 0; i < events.size(); ++i) {
+    // timestamps go up exponentially so the lower index is always closer in
+    // time than the higher index.
+    events[i].timestamp = static_cast<double>(i) * static_cast<double>(i);
+    event_ptrs.push_back(&events[i]);
+  }
+  events[0].name = "one";
+  events[2].name = "two";
+  events[4].name = "three";
+  Query query_named = Query(EVENT_NAME) != Query::String("");
+  Query query_one = Query(EVENT_NAME) == Query::String("one");
+
+  // Only one event matches query_one, so two closest can't be found.
+  EXPECT_FALSE(FindClosest(event_ptrs, query_one, 0, &index_1, &index_2));
+
+  EXPECT_TRUE(FindClosest(event_ptrs, query_one, 3, &index_1, NULL));
+  EXPECT_EQ(0u, index_1);
+
+  EXPECT_TRUE(FindClosest(event_ptrs, query_named, 1, &index_1, &index_2));
+  EXPECT_EQ(0u, index_1);
+  EXPECT_EQ(2u, index_2);
+
+  EXPECT_TRUE(FindClosest(event_ptrs, query_named, 4, &index_1, &index_2));
+  EXPECT_EQ(4u, index_1);
+  EXPECT_EQ(2u, index_2);
+
+  EXPECT_TRUE(FindClosest(event_ptrs, query_named, 3, &index_1, &index_2));
+  EXPECT_EQ(2u, index_1);
+  EXPECT_EQ(0u, index_2);
+}
+
+// Test CountMatches.
+TEST_F(TraceEventAnalyzerTest, CountMatches) {
+  using namespace trace_analyzer;
+
+  TraceEventVector event_ptrs;
+  EXPECT_EQ(0u, CountMatches(event_ptrs, Query::Bool(true), 0, 10));
+
+  size_t num_events = 5;
+  size_t num_named = 3;
+  std::vector<TraceEvent> events;
+  events.resize(num_events);
+  for (size_t i = 0; i < events.size(); ++i)
+    event_ptrs.push_back(&events[i]);
+  events[0].name = "one";
+  events[2].name = "two";
+  events[4].name = "three";
+  Query query_named = Query(EVENT_NAME) != Query::String("");
+  Query query_one = Query(EVENT_NAME) == Query::String("one");
+
+  EXPECT_EQ(0u, CountMatches(event_ptrs, Query::Bool(false)));
+  EXPECT_EQ(num_events, CountMatches(event_ptrs, Query::Bool(true)));
+  EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, Query::Bool(true),
+                                         1, num_events));
+  EXPECT_EQ(1u, CountMatches(event_ptrs, query_one));
+  EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, !query_one));
+  EXPECT_EQ(num_named, CountMatches(event_ptrs, query_named));
 }
 
 
 }  // namespace trace_analyzer