X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=dependencies64%2Fcef%2Flinux%2Ftests%2Fceftests%2Ftracing_unittest.cc;fp=dependencies64%2Fcef%2Flinux%2Ftests%2Fceftests%2Ftracing_unittest.cc;h=76389b81f78777b4f5fe855c9b4fd4f4d6899ed5;hb=8128744e46d808a1105fb449365d7028df8c32b4;hp=0000000000000000000000000000000000000000;hpb=3a0dc241f598cabf83bcc67970176453929a73f1;p=casparcg diff --git a/dependencies64/cef/linux/tests/ceftests/tracing_unittest.cc b/dependencies64/cef/linux/tests/ceftests/tracing_unittest.cc new file mode 100644 index 000000000..76389b81f --- /dev/null +++ b/dependencies64/cef/linux/tests/ceftests/tracing_unittest.cc @@ -0,0 +1,422 @@ +// Copyright (c) 2013 The Chromium Embedded Framework 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/base/cef_bind.h" +#include "include/cef_file_util.h" +#include "include/cef_task.h" +#include "include/cef_trace.h" +#include "include/cef_waitable_event.h" +#include "include/wrapper/cef_closure_task.h" +#include "tests/ceftests/file_util.h" +#include "tests/ceftests/test_handler.h" +#include "tests/gtest/include/gtest/gtest.h" + +// Use the CEF version of the TRACE_* macros instead of the Chromium version. +#undef USING_CHROMIUM_INCLUDES +#include "include/base/cef_trace_event.h" + +enum TracingTestType { + TT_TRACE_EVENT0, + TT_TRACE_EVENT1, + TT_TRACE_EVENT2, + TT_TRACE_EVENT_INSTANT0, + TT_TRACE_EVENT_INSTANT1, + TT_TRACE_EVENT_INSTANT2, + TT_TRACE_EVENT_COPY_INSTANT0, + TT_TRACE_EVENT_COPY_INSTANT1, + TT_TRACE_EVENT_COPY_INSTANT2, + TT_TRACE_EVENT_BEGIN0, + TT_TRACE_EVENT_BEGIN1, + TT_TRACE_EVENT_BEGIN2, + TT_TRACE_EVENT_COPY_BEGIN0, + TT_TRACE_EVENT_COPY_BEGIN1, + TT_TRACE_EVENT_COPY_BEGIN2, + TT_TRACE_EVENT_END0, + TT_TRACE_EVENT_END1, + TT_TRACE_EVENT_END2, + TT_TRACE_EVENT_COPY_END0, + TT_TRACE_EVENT_COPY_END1, + TT_TRACE_EVENT_COPY_END2, + TT_TRACE_COUNTER1, + TT_TRACE_COPY_COUNTER1, + TT_TRACE_COUNTER2, + TT_TRACE_COPY_COUNTER2, + TT_TRACE_COUNTER_ID1, + TT_TRACE_COPY_COUNTER_ID1, + TT_TRACE_COUNTER_ID2, + TT_TRACE_COPY_COUNTER_ID2, + TT_TRACE_EVENT_ASYNC_BEGIN0, + TT_TRACE_EVENT_ASYNC_BEGIN1, + TT_TRACE_EVENT_ASYNC_BEGIN2, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN0, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN1, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN2, + TT_TRACE_EVENT_ASYNC_STEP_INTO0, + TT_TRACE_EVENT_ASYNC_STEP_INTO1, + TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0, + TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1, + TT_TRACE_EVENT_ASYNC_STEP_PAST0, + TT_TRACE_EVENT_ASYNC_STEP_PAST1, + TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0, + TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1, + TT_TRACE_EVENT_ASYNC_END0, + TT_TRACE_EVENT_ASYNC_END1, + TT_TRACE_EVENT_ASYNC_END2, + TT_TRACE_EVENT_COPY_ASYNC_END0, + TT_TRACE_EVENT_COPY_ASYNC_END1, + TT_TRACE_EVENT_COPY_ASYNC_END2 +}; + +const char kTraceTestCategory[] = "test_category"; + +class TracingTestHandler : public CefEndTracingCallback, + public CefCompletionCallback { + public: + TracingTestHandler(TracingTestType type, const char* trace_type) + : trace_type_(trace_type), + type_(type) { + completion_event_ = CefWaitableEvent::CreateWaitableEvent(true, false); + } + + void ReadTracingFile(const std::string& file_path) { + EXPECT_FILE_THREAD(); + + EXPECT_TRUE(file_util::ReadFileToString(file_path, &trace_data_)); + EXPECT_TRUE(CefDeleteFile(file_path, false)); + + completion_event_->Signal(); + } + + // CefEndTracingCallback method: + void OnEndTracingComplete(const CefString& tracing_file) override { + EXPECT_UI_THREAD(); + + CefPostTask(TID_FILE, + base::Bind(&TracingTestHandler::ReadTracingFile, this, tracing_file)); + } + + void RunTracing() { + EXPECT_UI_THREAD(); + + // Results in a call to OnComplete. + CefBeginTracing(kTraceTestCategory, this); + } + + void OnComplete() override { + EXPECT_UI_THREAD(); + + switch (type_) { + case TT_TRACE_EVENT0: { + TRACE_EVENT0(kTraceTestCategory, "TT_TRACE_EVENT0"); + } break; + case TT_TRACE_EVENT1: { + TRACE_EVENT1(kTraceTestCategory, "TT_TRACE_EVENT1", "arg1", 1); + } break; + case TT_TRACE_EVENT2: { + TRACE_EVENT2(kTraceTestCategory, "TT_TRACE_EVENT2", "arg1", 1, + "arg2", 2); + } break; + case TT_TRACE_EVENT_INSTANT0: + TRACE_EVENT_INSTANT0(kTraceTestCategory, + "TT_TRACE_EVENT_INSTANT0"); + break; + case TT_TRACE_EVENT_INSTANT1: + TRACE_EVENT_INSTANT1(kTraceTestCategory, "TT_TRACE_EVENT_INSTANT1", + "arg1", 1); + break; + case TT_TRACE_EVENT_INSTANT2: + TRACE_EVENT_INSTANT2(kTraceTestCategory, "TT_TRACE_EVENT_INSTANT2", + "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_COPY_INSTANT0: + TRACE_EVENT_COPY_INSTANT0(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_INSTANT0"); + break; + case TT_TRACE_EVENT_COPY_INSTANT1: + TRACE_EVENT_COPY_INSTANT1(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_INSTANT1", + "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_INSTANT2: + TRACE_EVENT_COPY_INSTANT2(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_INSTANT2", + "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_BEGIN0: + TRACE_EVENT_BEGIN0(kTraceTestCategory, "TT_TRACE_EVENT_BEGIN0"); + break; + case TT_TRACE_EVENT_BEGIN1: + TRACE_EVENT_BEGIN1(kTraceTestCategory, "TT_TRACE_EVENT_BEGIN1", + "arg1", 1); + break; + case TT_TRACE_EVENT_BEGIN2: + TRACE_EVENT_BEGIN2(kTraceTestCategory, "TT_TRACE_EVENT_BEGIN2", + "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_COPY_BEGIN0: + TRACE_EVENT_COPY_BEGIN0(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_BEGIN0"); + break; + case TT_TRACE_EVENT_COPY_BEGIN1: + TRACE_EVENT_COPY_BEGIN1(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_BEGIN1", + "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_BEGIN2: + TRACE_EVENT_COPY_BEGIN2(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_BEGIN2", + "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_END0: + TRACE_EVENT_END0(kTraceTestCategory, "TT_TRACE_EVENT_END0"); + break; + case TT_TRACE_EVENT_END1: + TRACE_EVENT_END1(kTraceTestCategory, "TT_TRACE_EVENT_END1", + "arg1", 1); + break; + case TT_TRACE_EVENT_END2: + TRACE_EVENT_END2(kTraceTestCategory, "TT_TRACE_EVENT_END2", + "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_COPY_END0: + TRACE_EVENT_COPY_END0(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_END0"); + break; + case TT_TRACE_EVENT_COPY_END1: + TRACE_EVENT_COPY_END1(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_END1", "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_END2: + TRACE_EVENT_COPY_END2(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_END2", "arg1", 1, "arg2", 2); + break; + case TT_TRACE_COUNTER1: + TRACE_COUNTER1(kTraceTestCategory, "TT_TRACE_COUNTER1", 5); + break; + case TT_TRACE_COPY_COUNTER1: + TRACE_COPY_COUNTER1(kTraceTestCategory, "TT_TRACE_COPY_COUNTER1", 5); + break; + case TT_TRACE_COUNTER2: + TRACE_COUNTER2(kTraceTestCategory, "TT_TRACE_COUNTER2", "val1", 5, + "val2", 10); + break; + case TT_TRACE_COPY_COUNTER2: + TRACE_COPY_COUNTER2(kTraceTestCategory, "TT_TRACE_COPY_COUNTER2", + "val1", 5, "val2", 10); + break; + case TT_TRACE_COUNTER_ID1: + TRACE_COUNTER_ID1(kTraceTestCategory, "TT_TRACE_COUNTER_ID1", 100, 5); + break; + case TT_TRACE_COPY_COUNTER_ID1: + TRACE_COPY_COUNTER_ID1(kTraceTestCategory, + "TT_TRACE_COPY_COUNTER_ID1", 100, 5); + break; + case TT_TRACE_COUNTER_ID2: + TRACE_COUNTER_ID2(kTraceTestCategory, "TT_TRACE_COUNTER_ID2", 100, + "val1", 5, "val2", 10); + break; + case TT_TRACE_COPY_COUNTER_ID2: + TRACE_COPY_COUNTER_ID2(kTraceTestCategory, + "TT_TRACE_COPY_COUNTER_ID2", 100, + "val1", 5, "val2", 10); + break; + case TT_TRACE_EVENT_ASYNC_BEGIN0: + TRACE_EVENT_ASYNC_BEGIN0(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_BEGIN0", 100); + break; + case TT_TRACE_EVENT_ASYNC_BEGIN1: + TRACE_EVENT_ASYNC_BEGIN1(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_BEGIN1", 100, "arg1", 1); + break; + case TT_TRACE_EVENT_ASYNC_BEGIN2: + TRACE_EVENT_ASYNC_BEGIN2(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_BEGIN2", + 100, "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_COPY_ASYNC_BEGIN0: + TRACE_EVENT_COPY_ASYNC_BEGIN0(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_BEGIN0", + 100); + break; + case TT_TRACE_EVENT_COPY_ASYNC_BEGIN1: + TRACE_EVENT_COPY_ASYNC_BEGIN1(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_BEGIN1", + 100, "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_ASYNC_BEGIN2: + TRACE_EVENT_COPY_ASYNC_BEGIN2(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_BEGIN2", + 100, "arg1", 1, "arg2", 2); + break; + case TT_TRACE_EVENT_ASYNC_STEP_INTO0: + TRACE_EVENT_ASYNC_STEP_INTO0( + kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_INTO0", 100, 1000); + break; + case TT_TRACE_EVENT_ASYNC_STEP_INTO1: + TRACE_EVENT_ASYNC_STEP_INTO1( + kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_INTO1", 100, 1000, + "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0: + TRACE_EVENT_COPY_ASYNC_STEP_INTO0( + kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0", 100, + 1000); + break; + case TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1: + TRACE_EVENT_COPY_ASYNC_STEP_INTO1( + kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1", 100, + 1000, "arg1", 1); + break; + case TT_TRACE_EVENT_ASYNC_STEP_PAST0: + TRACE_EVENT_ASYNC_STEP_PAST0( + kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_PAST0", 100, 1000); + break; + case TT_TRACE_EVENT_ASYNC_STEP_PAST1: + TRACE_EVENT_ASYNC_STEP_PAST1( + kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_PAST1", 100, 1000, + "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0: + TRACE_EVENT_COPY_ASYNC_STEP_PAST0( + kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0", 100, + 1000); + break; + case TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1: + TRACE_EVENT_COPY_ASYNC_STEP_PAST1( + kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1", 100, + 1000, "arg1", 1); + break; + case TT_TRACE_EVENT_ASYNC_END0: + TRACE_EVENT_ASYNC_END0(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_END0", 100); + break; + case TT_TRACE_EVENT_ASYNC_END1: + TRACE_EVENT_ASYNC_END1(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_END1", 100, + "arg1", 1); + break; + case TT_TRACE_EVENT_ASYNC_END2: + TRACE_EVENT_ASYNC_END2(kTraceTestCategory, + "TT_TRACE_EVENT_ASYNC_END2", 100, + "arg1", 1, "arg2", 2); + case TT_TRACE_EVENT_COPY_ASYNC_END0: + TRACE_EVENT_COPY_ASYNC_END0(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_END0", + 100); + break; + case TT_TRACE_EVENT_COPY_ASYNC_END1: + TRACE_EVENT_COPY_ASYNC_END1(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_END1", + 100, "arg1", 1); + break; + case TT_TRACE_EVENT_COPY_ASYNC_END2: + TRACE_EVENT_COPY_ASYNC_END2(kTraceTestCategory, + "TT_TRACE_EVENT_COPY_ASYNC_END2", + 100, "arg1", 1, "arg2", 2); + break; + } + + // Results in a call to OnEndTracingComplete. + CefEndTracing(CefString(), this); + } + + void ExecuteTest() { + // Run the test. + CefPostTask(TID_UI, base::Bind(&TracingTestHandler::RunTracing, this)); + + // Wait for the test to complete. + completion_event_->Wait(); + + // Verify the results. + EXPECT_TRUE(!trace_data_.empty()); + EXPECT_TRUE(trace_type_ != NULL); + EXPECT_TRUE(strstr(trace_data_.c_str(), trace_type_) != NULL); + } + + private: + ~TracingTestHandler() override {} + + // Handle used to notify when the test is complete. + CefRefPtr completion_event_; + + const char* trace_type_; + TracingTestType type_; + std::string trace_data_; + + IMPLEMENT_REFCOUNTING(TracingTestHandler); +}; + +// Helper for defining tracing tests. +#define TRACING_TEST(name, test_type) \ + TEST(TracingTest, name) { \ + CefRefPtr handler = \ + new TracingTestHandler(test_type, #test_type); \ + handler->ExecuteTest(); \ + } + +// Define the tests. +TRACING_TEST(TraceEvent0, TT_TRACE_EVENT0); +TRACING_TEST(TraceEvent1, TT_TRACE_EVENT1); +TRACING_TEST(TraceEvent2, TT_TRACE_EVENT2); +TRACING_TEST(TraceEventInstant0, TT_TRACE_EVENT_INSTANT0); +TRACING_TEST(TraceEventInstant1, TT_TRACE_EVENT_INSTANT1); +TRACING_TEST(TraceEventInstant2, TT_TRACE_EVENT_INSTANT2); +TRACING_TEST(TraceEventCopyInstant0, TT_TRACE_EVENT_COPY_INSTANT0); +TRACING_TEST(TraceEventCopyInstant1, TT_TRACE_EVENT_COPY_INSTANT1); +TRACING_TEST(TraceEventCopyInstant2, TT_TRACE_EVENT_COPY_INSTANT2); +TRACING_TEST(TraceEventBegin0, TT_TRACE_EVENT_BEGIN0); +TRACING_TEST(TraceEventBegin1, TT_TRACE_EVENT_BEGIN1); +TRACING_TEST(TraceEventBegin2, TT_TRACE_EVENT_BEGIN2); +TRACING_TEST(TraceEventCopyBegin0, TT_TRACE_EVENT_COPY_BEGIN0); +TRACING_TEST(TraceEventCopyBegin1, TT_TRACE_EVENT_COPY_BEGIN1); +TRACING_TEST(TraceEventCopyBegin2, TT_TRACE_EVENT_COPY_BEGIN2); +TRACING_TEST(TraceEventEnd0, TT_TRACE_EVENT_END0); +TRACING_TEST(TraceEventEnd1, TT_TRACE_EVENT_END1); +TRACING_TEST(TraceEventEnd2, TT_TRACE_EVENT_END2); +TRACING_TEST(TraceEventCopyEnd0, TT_TRACE_EVENT_COPY_END0); +TRACING_TEST(TraceEventCopyEnd1, TT_TRACE_EVENT_COPY_END1); +TRACING_TEST(TraceEventCopyEnd2, TT_TRACE_EVENT_COPY_END1); +TRACING_TEST(TraceCounter1, TT_TRACE_COUNTER1); +TRACING_TEST(TraceCopyCounter1, TT_TRACE_COPY_COUNTER1); +TRACING_TEST(TraceCounter2, TT_TRACE_COUNTER2); +TRACING_TEST(TraceCopyCounter2, TT_TRACE_COPY_COUNTER2); +TRACING_TEST(TraceCounterId1, TT_TRACE_COUNTER_ID1); +TRACING_TEST(TraceCopyCounterId1, TT_TRACE_COPY_COUNTER_ID1); +TRACING_TEST(TraceCounterId2, TT_TRACE_COUNTER_ID2); +TRACING_TEST(TraceCopyCounterId2, TT_TRACE_COPY_COUNTER_ID1); +TRACING_TEST(TraceEventAsyncBegin0, TT_TRACE_EVENT_ASYNC_BEGIN0); +TRACING_TEST(TraceEventAsyncBegin1, TT_TRACE_EVENT_ASYNC_BEGIN1); +TRACING_TEST(TraceEventAsyncBegin2, TT_TRACE_EVENT_ASYNC_BEGIN2); +TRACING_TEST(TraceEventCopyAsyncBegin0, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN0); +TRACING_TEST(TraceEventCopyAsyncBegin1, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN1); +TRACING_TEST(TraceEventCopyAsyncBegin2, + TT_TRACE_EVENT_COPY_ASYNC_BEGIN2); +TRACING_TEST(TraceEventAsyncStepInto0, + TT_TRACE_EVENT_ASYNC_STEP_INTO0); +TRACING_TEST(TraceEventAsyncStepInto1, + TT_TRACE_EVENT_ASYNC_STEP_INTO1); +TRACING_TEST(TraceEventCopyAsyncStepInto0, + TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0); +TRACING_TEST(TraceEventCopyAsyncStepInto1, + TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1); +TRACING_TEST(TraceEventAsyncStepPast0, + TT_TRACE_EVENT_ASYNC_STEP_PAST0); +TRACING_TEST(TraceEventAsyncStepPast1, + TT_TRACE_EVENT_ASYNC_STEP_PAST1); +TRACING_TEST(TraceEventCopyAsyncStepPast0, + TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0); +TRACING_TEST(TraceEventCopyAsyncStepPast1, + TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1); +TRACING_TEST(TraceEventAsyncEnd0, TT_TRACE_EVENT_ASYNC_END0); +TRACING_TEST(TraceEventAsyncEnd1, TT_TRACE_EVENT_ASYNC_END1); +TRACING_TEST(TraceEventAsyncEnd2, TT_TRACE_EVENT_ASYNC_END2); +TRACING_TEST(TraceEventCopyAsyncEnd0, TT_TRACE_EVENT_COPY_ASYNC_END0); + + +TEST(TracingTest, NowFromSystemTraceTime) { + int64 val = CefNowFromSystemTraceTime(); + EXPECT_NE(val, 0); +}