Internalize JSON chunk management to trace_event.h API.

base/debug/trace_event_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/debug/trace_event.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 22 matching lines @@
   const char* value;
   CompareOp op;
 };
 
 class TraceEventTestFixture : public testing::Test {
  public:
   // This fixture does not use SetUp() because the fixture must be manually set
   // up multiple times when testing AtExit. Use ManualTestSetUp for this.
   void ManualTestSetUp();
   void OnTraceDataCollected(
-      scoped_refptr<TraceLog::RefCountedString> json_events_str);
+      scoped_refptr<TraceLog::RefCountedString> events_str);
   bool FindMatchingTraceEntry(const JsonKeyValue* key_values);
   bool FindNamePhase(const char* name, const char* phase);
   bool FindMatchingValue(const char* key,
                          const char* value);
   bool FindNonMatchingValue(const char* key,
                             const char* value);
   void Clear() {
-    trace_string_.clear();
     trace_parsed_.Clear();
+    json_output_.json_output.clear();
   }
 
-  std::string trace_string_;
   ListValue trace_parsed_;
+  base::debug::TraceResultBuffer trace_buffer_;
+  base::debug::TraceResultBuffer::SimpleOutput json_output_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
 void TraceEventTestFixture::ManualTestSetUp() {
   TraceLog::DeleteForTesting();
   TraceLog::Resurrect();
   TraceLog* tracelog = TraceLog::GetInstance();
   ASSERT_TRUE(tracelog);
   ASSERT_FALSE(tracelog->IsEnabled());
   tracelog->SetOutputCallback(
       base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
                  base::Unretained(this)));
+  trace_buffer_.SetOutputCallback(json_output_.GetCallback());
 }
 
 void TraceEventTestFixture::OnTraceDataCollected(
-    scoped_refptr<TraceLog::RefCountedString> json_events_str) {
+    scoped_refptr<TraceLog::RefCountedString> events_str) {
   AutoLock lock(lock_);
-  trace_string_ += json_events_str->data;
+  json_output_.json_output.clear();
+  trace_buffer_.Start();
+  trace_buffer_.AddFragment(events_str->data);
+  trace_buffer_.Finish();
 
   scoped_ptr<Value> root;
-  root.reset(base::JSONReader::Read(json_events_str->data, false));
+  root.reset(base::JSONReader::Read(json_output_.json_output, false));
 
   ListValue* root_list = NULL;
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->GetAsList(&root_list));
 
   // Move items into our aggregate collection
   while (root_list->GetSize()) {
     Value* item = NULL;
     root_list->Remove(0, &item);
     trace_parsed_.Append(item);
@@ skipping 182 matching lines @@
     TRACE_EVENT_END1("all", "TRACE_EVENT_END1 call", "name1", "value1");
     TRACE_EVENT_END2("all", "TRACE_EVENT_END2 call",
                      "name1", "value1",
                      "name2", "value2");
   } // Scope close causes TRACE_EVENT0 etc to send their END events.
 
   if (task_complete_event)
     task_complete_event->Signal();
 }
 
-void ValidateAllTraceMacrosCreatedData(const ListValue& trace_parsed,
-                                 const std::string& trace_string) {
+void ValidateAllTraceMacrosCreatedData(const ListValue& trace_parsed) {
   DictionaryValue* item = NULL;
 
 #define EXPECT_FIND_(string) \
     EXPECT_TRUE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_NOT_FIND_(string) \
     EXPECT_FALSE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_SUB_FIND_(string) \
     if (item) EXPECT_TRUE((IsStringInDict(string, item)));
 
   EXPECT_FIND_("ETW Trace Event");
@@ skipping 42 matching lines @@
   EXPECT_FIND_("TRACE_EVENT_END0 call");
   EXPECT_FIND_("TRACE_EVENT_END1 call");
   EXPECT_FIND_("TRACE_EVENT_END2 call");
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("value1");
   EXPECT_SUB_FIND_("name2");
   EXPECT_SUB_FIND_("value2");
 }
 
 void TraceManyInstantEvents(int thread_id, int num_events,
-                                 WaitableEvent* task_complete_event) {
+                            WaitableEvent* task_complete_event) {
   for (int i = 0; i < num_events; i++) {
     TRACE_EVENT_INSTANT2("all", "multi thread event",
                          "thread", thread_id,
                          "event", i);
   }
 
   if (task_complete_event)
     task_complete_event->Signal();
 }
 
 void ValidateInstantEventPresentOnEveryThread(const ListValue& trace_parsed,
-                                     const std::string& trace_string,
-                                     int num_threads, int num_events) {
+                                              int num_threads,
+                                              int num_events) {
   std::map<int, std::map<int, bool> > results;
 
   size_t trace_parsed_count = trace_parsed.GetSize();
   for (size_t i = 0; i < trace_parsed_count; i++) {
     Value* value = NULL;
     trace_parsed.Get(i, &value);
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
     DictionaryValue* dict = static_cast<DictionaryValue*>(value);
     std::string name;
@@ skipping 27 matching lines @@
 
 // Simple Test for emitting data and validating it was received.
 TEST_F(TraceEventTestFixture, DataCaptured) {
   ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(true);
 
   TraceWithAllMacroVariants(NULL);
 
   TraceLog::GetInstance()->SetEnabled(false);
 
-  ValidateAllTraceMacrosCreatedData(trace_parsed_, trace_string_);
+  ValidateAllTraceMacrosCreatedData(trace_parsed_);
 }
 
 // Test that categories work.
 TEST_F(TraceEventTestFixture, Categories) {
   ManualTestSetUp();
 
   // Test that categories that are used can be retrieved whether trace was
   // enabled or disabled when the trace event was encountered.
   TRACE_EVENT_INSTANT0("c1", "name");
   TRACE_EVENT_INSTANT0("c2", "name");
@@ skipping 260 matching lines @@
   Thread thread("1");
   WaitableEvent task_complete_event(false, false);
   thread.Start();
 
   thread.message_loop()->PostTask(
       FROM_HERE, base::Bind(&TraceWithAllMacroVariants, &task_complete_event));
   task_complete_event.Wait();
   thread.Stop();
 
   TraceLog::GetInstance()->SetEnabled(false);
-  ValidateAllTraceMacrosCreatedData(trace_parsed_, trace_string_);
+  ValidateAllTraceMacrosCreatedData(trace_parsed_);
 }
 
 // Test that data sent from multiple threads is gathered
 TEST_F(TraceEventTestFixture, DataCapturedManyThreads) {
   ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(true);
 
   const int num_threads = 4;
   const int num_events = 4000;
   Thread* threads[num_threads];
@@ skipping 12 matching lines @@
   }
 
   for (int i = 0; i < num_threads; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
   TraceLog::GetInstance()->SetEnabled(false);
 
-  ValidateInstantEventPresentOnEveryThread(trace_parsed_, trace_string_,
+  ValidateInstantEventPresentOnEveryThread(trace_parsed_,
                                            num_threads, num_events);
 }
 
 // Test that thread and process names show up in the trace
 TEST_F(TraceEventTestFixture, ThreadNames) {
   ManualTestSetUp();
 
   // Create threads before we enable tracing to make sure
   // that tracelog still captures them.
   const int num_threads = 4;
@@ skipping 184 matching lines @@
   EXPECT_TRUE(entry2->GetInteger("args.arg1", &i));
   EXPECT_EQ(5, i);
 
   std::string s;
   EXPECT_TRUE(entry3->GetString("args.arg1", &s));
   EXPECT_EQ("val1", s);
   EXPECT_TRUE(entry3->GetString("args.arg2", &s));
   EXPECT_EQ("val2", s);
 }
 
+// Test that TraceResultBuffer outputs the correct result whether it is added
+// in chunks or added all at once.
+TEST_F(TraceEventTestFixture, TraceResultBuffer) {
+  ManualTestSetUp();
+
+  Clear();
+
+  trace_buffer_.Start();
+  trace_buffer_.AddFragment("bla1");
+  trace_buffer_.AddFragment("bla2");
+  trace_buffer_.AddFragment("bla3,bla4");
+  trace_buffer_.Finish();
+  EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
+
+  Clear();

[nduca, 2011/10/20 23:20:05]

This is two tests, no?

[jbates, 2011/10/20 23:55:13]

Easier to follow in one test IMO. Is there a rule about this that I don't know?

+
+  trace_buffer_.Start();
+  trace_buffer_.AddFragment("bla1,bla2,bla3,bla4");
+  trace_buffer_.Finish();
+  EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
+}
+

[nduca, 2011/10/20 23:20:05]

Output callback test?
Any corner cases?

Not a big deal if you're feeling overwhelmed.

[jbates, 2011/10/20 23:55:13]

Output callback is tested by every other test now, so I think it's covered.

 }  // namespace debug
 }  // namespace base