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..59eee2f34cd01a2042714ce98ddd21da95f82bed
--- /dev/null
+++ b/test/unittests/tracing/trace-event-unittest.cc
@@ -0,0 +1,242 @@
+// 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 "testing/gtest-support.h"
+
+static uint64_t isolate_id = 42;
+static uint64_t MockIsolateId() { return isolate_id; }
+#define INTERNAL_GET_TRACE_CONTEXT_ID MockIsolateId
+#include "src/tracing/trace-event.h"
+
+#define GET_TRACE_OBJECTS_LIST mock_event_tracer->GetMockTraceObjects()
+
+#define GET_TRACE_OBJECT(Index) GET_TRACE_OBJECTS_LIST->at(Index)
+
+namespace v8 {
+namespace internal {
+namespace tracing {
+
+struct MockTraceObject {
+  char phase;
+  const char* name;
+  uint64_t id;
+  uint64_t context_id;
+  uint64_t bind_id;
+  int numArgs;
+  unsigned int flags;
+  MockTraceObject(char phase, const char* name, uint64_t id,
+                  uint64_t context_id, uint64_t bind_id, int numArgs, int flags)
+      : phase(phase),
+        name(name),
+        id(id),
+        context_id(context_id),
+        bind_id(bind_id),
+        numArgs(numArgs),
+        flags(flags) {}
+};
+
+typedef 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, uint64_t context_id, uint64_t bind_id, int numArgs,
+      const char** argNames, const uint8_t* argTypes, const uint64_t* argValues,
+      unsigned int flags) {
+    MockTraceObject* to = new MockTraceObject(phase, name, id, context_id,
+                                              bind_id, numArgs, flags);
+    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);
+}
+
+
+TEST(TraceEvent, ScopedTraceEvent) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  { TRACE_EVENT0("v8-cat", "e"); }
+
+  EXPECT_EQ(1, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(0, GET_TRACE_OBJECT(0)->numArgs);
+
+  { TRACE_EVENT1("v8-cat", "e1", "arg1", "abc"); }
+
+  EXPECT_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(1, GET_TRACE_OBJECT(1)->numArgs);
+
+  { TRACE_EVENT2("v8-cat", "e1", "arg1", "abc", "arg2", 42); }
+
+  EXPECT_EQ(3, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(2, GET_TRACE_OBJECT(2)->numArgs);
+}
+
+
+TEST(TraceEvent, TestMultipleIsolates) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  isolate_id = 42;
+  TRACE_EVENT_INSTANT0("v8-cat", "i1", TRACE_EVENT_SCOPE_THREAD);
+  isolate_id = 43;
+  TRACE_EVENT_INSTANT0("v8-cat", "i2", TRACE_EVENT_SCOPE_THREAD);
+
+  EXPECT_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(42, GET_TRACE_OBJECT(0)->context_id);
+  EXPECT_EQ(TRACE_EVENT_FLAG_HAS_CONTEXT_ID | TRACE_EVENT_SCOPE_THREAD,
+            GET_TRACE_OBJECT(0)->flags);
+  EXPECT_EQ(43, GET_TRACE_OBJECT(1)->context_id);
+  EXPECT_EQ(TRACE_EVENT_FLAG_HAS_CONTEXT_ID | TRACE_EVENT_SCOPE_THREAD,
+            GET_TRACE_OBJECT(1)->flags);
+}
+
+
+TEST(TraceEvent, TestEventWithFlow) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  static uint64_t bind_id = 21;
+  {
+    TRACE_EVENT_WITH_FLOW0("v8-cat", "f1", bind_id, TRACE_EVENT_FLAG_FLOW_OUT);
+  }
+  {
+    TRACE_EVENT_WITH_FLOW0(
+        "v8-cat", "f2", bind_id,
+        TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
+  }
+  { TRACE_EVENT_WITH_FLOW0("v8-cat", "f3", bind_id, TRACE_EVENT_FLAG_FLOW_IN); }
+
+  EXPECT_EQ(3, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(bind_id, GET_TRACE_OBJECT(0)->bind_id);
+  EXPECT_EQ(TRACE_EVENT_FLAG_HAS_CONTEXT_ID | TRACE_EVENT_FLAG_FLOW_OUT,
+            GET_TRACE_OBJECT(0)->flags);
+  EXPECT_EQ(bind_id, GET_TRACE_OBJECT(1)->bind_id);
+  EXPECT_EQ(TRACE_EVENT_FLAG_HAS_CONTEXT_ID | TRACE_EVENT_FLAG_FLOW_IN |
+                TRACE_EVENT_FLAG_FLOW_OUT,
+            GET_TRACE_OBJECT(1)->flags);
+  EXPECT_EQ(bind_id, GET_TRACE_OBJECT(2)->bind_id);
+  EXPECT_EQ(TRACE_EVENT_FLAG_HAS_CONTEXT_ID | TRACE_EVENT_FLAG_FLOW_IN,
+            GET_TRACE_OBJECT(2)->flags);
+}
+
+
+TEST(TraceEvent, TestEventWithId) {
+  MockEventTracer* mock_event_tracer = new MockEventTracer();
+  v8::EventTracer::SetInstance(mock_event_tracer);
+
+  static uint64_t event_id = 21;
+  TRACE_EVENT_ASYNC_BEGIN0("v8-cat", "a1", event_id);
+  TRACE_EVENT_ASYNC_END0("v8-cat", "a1", event_id);
+
+  EXPECT_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_BEGIN, GET_TRACE_OBJECT(0)->phase);
+  EXPECT_EQ(event_id, GET_TRACE_OBJECT(0)->id);
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_END, GET_TRACE_OBJECT(1)->phase);
+  EXPECT_EQ(event_id, GET_TRACE_OBJECT(1)->id);
+}
+
+}  // namespace tracing
+}  // namespace internal
+}  // namespace v8
+
+#undef INTERNAL_GET_TRACE_CONTEXT_ID