Implement tracing interface for v8

test/unittests/tracing/trace-event-unittest.cc

Index: test/unittests/tracing/trace-event-unittest.cc
diff --git a/test/unittests/tracing/trace-event-unittest.cc b/test/unittests/tracing/trace-event-unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3180a731a8b11a4d235bd7c46e589123feccf4c4
--- /dev/null
+++ b/test/unittests/tracing/trace-event-unittest.cc
@@ -0,0 +1,143 @@
+// Copyright 2015 the V8 project 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 <include/v8-tracing.h>
+
+#include "src/list.h"
+#include "src/list-inl.h"
+#include "src/tracing/trace-event.h"
+#include "testing/gtest-support.h"
+
+
+#define GET_TRACE_OBJECTS_LIST \
+  mock_event_tracer->GetMockTraceObjects()
+
+#define GET_TRACE_OBJECT(Index) \
+  GET_TRACE_OBJECTS_LIST->at(Index)
+
+namespace v8 {
+namespace tracing_internals {
+
+struct MockTraceObject {
+  char phase;
+  const char* name;
+  int numArgs;
+  MockTraceObject(char phase, const char* name, int numArgs):
+    phase(phase), name(name), numArgs(numArgs){}
+};
+
+typedef internal::List<MockTraceObject*> MockTraceObjectList;
+
+class MockEventTracer : public v8::EventTracer {
+  virtual v8::EventTracer::Handle AddTraceEvent(
+      char phase, const uint8_t* categoryEnabledFlag, const char* name,
+      uint64_t id, int numArgs, const char** argNames, const uint8_t* argTypes,
+      const uint64_t* argValues, uint8_t flags) {
+    MockTraceObject* to = new MockTraceObject(phase, name, numArgs);
+    trace_object_list_.Add(to);
+    return 0;
+  }
+
+  virtual void UpdateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                        const char* name,
+                                        EventTracer::Handle handle) {}
+
+  virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
+    if (strcmp(name, "v8-cat")) {
+      static uint8_t no = 0;
+      return &no;
+    } else {
+      static uint8_t yes = 0x7;
+      return &yes;
+    }
+  }
+
+  virtual const char* GetCategoryGroupName(const uint8_t* categoryEnabledFlag) {
+    static const char* dummy = "dummy";
+    return dummy;
+  }
+
+  MockTraceObjectList trace_object_list_;
+
+ public:
+  ~MockEventTracer() {
+    for (int i = 0; i < trace_object_list_.length(); ++i) {
+      delete trace_object_list_[i];
+    }
+    trace_object_list_.Clear();
+  }
+
+  MockTraceObjectList* GetMockTraceObjects() {
+    return &trace_object_list_;
+  }
+};
+
+
+TEST(TraceEvent, TraceEventDisabledCategory) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  // Disabled category, will not add events.
+  TRACE_EVENT_BEGIN0("cat", "e1");
+  TRACE_EVENT_END0("cat", "e1");
+  EXPECT_EQ(0, GET_TRACE_OBJECTS_LIST->length());
+}
+
+
+TEST(TraceEvent, TraceEventNoArgs) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  // Enabled category will add 2 events.
+  TRACE_EVENT_BEGIN0("v8-cat", "e1");
+  TRACE_EVENT_END0("v8-cat", "e1");
+
+  EXPECT_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ('B', GET_TRACE_OBJECT(0)->phase);
+  EXPECT_EQ("e1", GET_TRACE_OBJECT(0)->name);
+  EXPECT_EQ(0, GET_TRACE_OBJECT(0)->numArgs);
+
+  EXPECT_EQ('E', GET_TRACE_OBJECT(1)->phase);
+  EXPECT_EQ("e1", GET_TRACE_OBJECT(1)->name);
+  EXPECT_EQ(0, GET_TRACE_OBJECT(1)->numArgs);
+}
+
+
+TEST(TraceEvent, TraceEventWithOneArg) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  TRACE_EVENT_BEGIN1("v8-cat", "e1", "arg1", 42);
+  TRACE_EVENT_END1("v8-cat", "e1", "arg1", 42);
+  TRACE_EVENT_BEGIN1("v8-cat", "e2", "arg1", "abc");
+  TRACE_EVENT_END1("v8-cat", "e2", "arg1", "abc");
+
+  EXPECT_EQ(4, GET_TRACE_OBJECTS_LIST->length());
+
+  EXPECT_EQ(1, GET_TRACE_OBJECT(0)->numArgs);
+  EXPECT_EQ(1, GET_TRACE_OBJECT(1)->numArgs);
+  EXPECT_EQ(1, GET_TRACE_OBJECT(2)->numArgs);
+  EXPECT_EQ(1, GET_TRACE_OBJECT(3)->numArgs);
+}
+
+
+TEST(TraceEvent, TraceEventWithTwoArgs) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  TRACE_EVENT_BEGIN2("v8-cat", "e1", "arg1", 42, "arg2", "abc");
+  TRACE_EVENT_END2("v8-cat", "e1", "arg1", 42, "arg2", "abc");
+  TRACE_EVENT_BEGIN2("v8-cat", "e2", "arg1", "abc", "arg2", 43);
+  TRACE_EVENT_END2("v8-cat", "e2", "arg1", "abc", "arg2", 43);
+
+  EXPECT_EQ(4, GET_TRACE_OBJECTS_LIST->length());
+
+  EXPECT_EQ(2, GET_TRACE_OBJECT(0)->numArgs);
+  EXPECT_EQ(2, GET_TRACE_OBJECT(1)->numArgs);
+  EXPECT_EQ(2, GET_TRACE_OBJECT(2)->numArgs);
+  EXPECT_EQ(2, GET_TRACE_OBJECT(3)->numArgs);
+}
+
+}  // namespace tracing_internals
+}  // namespace v8