perfetto: add end to end integration tests
These tests will run on a new target known as perfetto_integrationtests
with perfetto_tests renamed to perfetto_unittests.
Change-Id: I467eafd84cade516861f79295f06bb0768e46a30
diff --git a/.travis.yml b/.travis.yml
index 399457a..17c5dbf 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -146,7 +146,8 @@
- tools/ninja -C out/dist -j8 all
- |
TEST_TARGETS="
- perfetto_tests
+ perfetto_integrationtests
+ perfetto_unittests
perfetto_benchmarks
"
if [[ "$CFG" != android-* ]]; then
diff --git a/Android.bp b/Android.bp
index 211ad15..908e647 100644
--- a/Android.bp
+++ b/Android.bp
@@ -169,6 +169,86 @@
],
}
+// GN target: //:perfetto_integrationtests
+cc_test {
+ name: "perfetto_integrationtests",
+ srcs: [
+ ":perfetto_protos_perfetto_config_config_gen",
+ ":perfetto_protos_perfetto_ipc_ipc_gen",
+ ":perfetto_protos_perfetto_trace_ftrace_lite_gen",
+ ":perfetto_protos_perfetto_trace_ftrace_zero_gen",
+ ":perfetto_protos_perfetto_trace_lite_gen",
+ ":perfetto_protos_perfetto_trace_zero_gen",
+ ":perfetto_src_ipc_wire_protocol_gen",
+ "src/base/android_task_runner.cc",
+ "src/base/page_allocator.cc",
+ "src/base/test/test_task_runner.cc",
+ "src/base/test/vm_test_utils.cc",
+ "src/base/thread_checker.cc",
+ "src/base/unix_task_runner.cc",
+ "src/ftrace_reader/cpu_reader.cc",
+ "src/ftrace_reader/end_to_end_integrationtest.cc",
+ "src/ftrace_reader/event_info.cc",
+ "src/ftrace_reader/format_parser.cc",
+ "src/ftrace_reader/ftrace_controller.cc",
+ "src/ftrace_reader/ftrace_procfs.cc",
+ "src/ftrace_reader/ftrace_procfs_integrationtest.cc",
+ "src/ftrace_reader/proto_translation_table.cc",
+ "src/ftrace_reader/test/scattered_stream_delegate_for_testing.cc",
+ "src/ipc/buffered_frame_deserializer.cc",
+ "src/ipc/client_impl.cc",
+ "src/ipc/deferred.cc",
+ "src/ipc/host_impl.cc",
+ "src/ipc/service_proxy.cc",
+ "src/ipc/unix_socket.cc",
+ "src/protozero/proto_utils.cc",
+ "src/protozero/protozero_message.cc",
+ "src/protozero/protozero_message_handle.cc",
+ "src/protozero/scattered_stream_writer.cc",
+ "src/traced/probes/ftrace_producer.cc",
+ "src/tracing/core/chunked_protobuf_input_stream.cc",
+ "src/tracing/core/data_source_config.cc",
+ "src/tracing/core/data_source_descriptor.cc",
+ "src/tracing/core/id_allocator.cc",
+ "src/tracing/core/service_impl.cc",
+ "src/tracing/core/shared_memory_abi.cc",
+ "src/tracing/core/shared_memory_arbiter_impl.cc",
+ "src/tracing/core/trace_config.cc",
+ "src/tracing/core/trace_packet.cc",
+ "src/tracing/core/trace_writer_impl.cc",
+ "test/end_to_end_integrationtest.cc",
+ "test/fake_consumer.cc",
+ "test/fake_producer.cc",
+ ],
+ shared_libs: [
+ "libandroid",
+ "liblog",
+ "libprotobuf-cpp-lite",
+ ],
+ static_libs: [
+ "libgmock",
+ "libgtest_prod",
+ "perfetto_src_tracing_ipc",
+ ],
+ generated_headers: [
+ "perfetto_protos_perfetto_config_config_gen_headers",
+ "perfetto_protos_perfetto_ipc_ipc_gen_headers",
+ "perfetto_protos_perfetto_trace_ftrace_lite_gen_headers",
+ "perfetto_protos_perfetto_trace_ftrace_zero_gen_headers",
+ "perfetto_protos_perfetto_trace_lite_gen_headers",
+ "perfetto_protos_perfetto_trace_zero_gen_headers",
+ "perfetto_src_ipc_wire_protocol_gen_headers",
+ ],
+ defaults: [
+ "perfetto_defaults",
+ ],
+ cflags: [
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DPERFETTO_BUILD_WITH_ANDROID",
+ ],
+}
+
// GN target: //protos/perfetto/config:config_gen
genrule {
name: "perfetto_protos_perfetto_config_config_gen",
@@ -795,9 +875,9 @@
],
}
-// GN target: //:perfetto_tests
+// GN target: //:perfetto_unittests
cc_test {
- name: "perfetto_tests",
+ name: "perfetto_unittests",
srcs: [
":perfetto_protos_perfetto_config_config_gen",
":perfetto_protos_perfetto_ipc_ipc_gen",
diff --git a/BUILD.gn b/BUILD.gn
index a5b0d44..bb5863a 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -25,7 +25,7 @@
group("all") {
testonly = true # allow to build also test targets
deps = [
- ":perfetto_tests",
+ ":perfetto_unittests",
"src/ipc/protoc_plugin:ipc_plugin($host_toolchain)",
"src/protozero/protoc_plugin($host_toolchain)",
"tools/ftrace_proto_gen:ftrace_proto_gen",
@@ -36,17 +36,17 @@
deps += [
":perfetto",
":perfetto_benchmarks",
+ ":perfetto_integrationtests",
":traced",
":traced_probes",
"protos/perfetto/config:merged_config", # For syntax-checking the proto.
- "src/ftrace_reader:ftrace_reader_integrationtests",
"test/configs",
"tools:protoc_helper",
]
}
}
-executable("perfetto_tests") {
+executable("perfetto_unittests") {
testonly = true
deps = [
"gn:default_deps",
@@ -71,6 +71,18 @@
]
}
+ executable("perfetto_integrationtests") {
+ testonly = true
+ deps = [
+ "gn:default_deps",
+ "src/ftrace_reader:ftrace_reader_integrationtests",
+ "test:end_to_end_integrationtests",
+ ]
+ if (build_with_android) {
+ cflags = [ "-DPERFETTO_BUILD_WITH_ANDROID" ]
+ }
+ }
+
if (monolithic_binaries) {
libtraced_shared_target_type = "source_set"
} else {
diff --git a/include/perfetto/base/build_config.h b/include/perfetto/base/build_config.h
index 98f9ef2..420c2b2 100644
--- a/include/perfetto/base/build_config.h
+++ b/include/perfetto/base/build_config.h
@@ -41,6 +41,12 @@
#error OS not supported (see build_config.h)
#endif
+#if defined(PERFETTO_BUILD_WITH_ANDROID)
+#define BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD() 1
+#else
+#define BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD() 0
+#endif
+
#if defined(PERFETTO_BUILD_WITH_CHROMIUM)
#define BUILDFLAG_DEFINE_PERFETTO_CHROMIUM_BUILD() 1
#else
diff --git a/src/base/debug_crash_stack_trace.cc b/src/base/debug_crash_stack_trace.cc
index a81fefc..8990a14 100644
--- a/src/base/debug_crash_stack_trace.cc
+++ b/src/base/debug_crash_stack_trace.cc
@@ -165,7 +165,7 @@
// Pre-allocate the string for __cxa_demangle() to reduce the risk of that
// invoking realloc() within the signal handler.
g_demangled_name = reinterpret_cast<char*>(malloc(kDemangledNameLen));
- struct sigaction sigact;
+ struct sigaction sigact = {};
sigact.sa_sigaction = &SignalHandler;
sigact.sa_flags = static_cast<decltype(sigact.sa_flags)>(
SA_RESTART | SA_SIGINFO | SA_RESETHAND);
diff --git a/src/ftrace_reader/BUILD.gn b/src/ftrace_reader/BUILD.gn
index 94a9e57..5890d21 100644
--- a/src/ftrace_reader/BUILD.gn
+++ b/src/ftrace_reader/BUILD.gn
@@ -66,7 +66,7 @@
# These tests require access to a real ftrace implementation and must
# run with sudo.
-executable("ftrace_reader_integrationtests") {
+source_set("ftrace_reader_integrationtests") {
testonly = true
deps = [
":ftrace_reader",
diff --git a/src/ftrace_reader/ftrace_procfs_integrationtest.cc b/src/ftrace_reader/ftrace_procfs_integrationtest.cc
index 0fe9b88..ac84643 100644
--- a/src/ftrace_reader/ftrace_procfs_integrationtest.cc
+++ b/src/ftrace_reader/ftrace_procfs_integrationtest.cc
@@ -50,15 +50,16 @@
} // namespace
-TEST(FtraceProcfsIntegrationTest, CreateWithGoodPath) {
+// TODO(lalitm): reenable these thests (see b/72306171).
+TEST(FtraceProcfsIntegrationTest, DISABLED_CreateWithGoodPath) {
EXPECT_TRUE(FtraceProcfs::Create(kTracingPath));
}
-TEST(FtraceProcfsIntegrationTest, CreateWithBadPath) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_CreateWithBadPath) {
EXPECT_FALSE(FtraceProcfs::Create(kTracingPath + std::string("bad_path")));
}
-TEST(FtraceProcfsIntegrationTest, ClearTrace) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_ClearTrace) {
FtraceProcfs ftrace(kTracingPath);
ResetFtrace(&ftrace);
ftrace.WriteTraceMarker("Hello, World!");
@@ -66,14 +67,14 @@
EXPECT_THAT(GetTraceOutput(), Not(HasSubstr("Hello, World!")));
}
-TEST(FtraceProcfsIntegrationTest, TraceMarker) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_TraceMarker) {
FtraceProcfs ftrace(kTracingPath);
ResetFtrace(&ftrace);
ftrace.WriteTraceMarker("Hello, World!");
EXPECT_THAT(GetTraceOutput(), HasSubstr("Hello, World!"));
}
-TEST(FtraceProcfsIntegrationTest, EnableDisableEvent) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_EnableDisableEvent) {
FtraceProcfs ftrace(kTracingPath);
ResetFtrace(&ftrace);
ftrace.EnableEvent("sched", "sched_switch");
@@ -86,7 +87,7 @@
EXPECT_THAT(GetTraceOutput(), Not(HasSubstr("sched_switch")));
}
-TEST(FtraceProcfsIntegrationTest, EnableDisableTracing) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_EnableDisableTracing) {
FtraceProcfs ftrace(kTracingPath);
ResetFtrace(&ftrace);
EXPECT_TRUE(ftrace.IsTracingEnabled());
@@ -102,20 +103,20 @@
EXPECT_THAT(GetTraceOutput(), HasSubstr("After"));
}
-TEST(FtraceProcfsIntegrationTest, ReadFormatFile) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_ReadFormatFile) {
FtraceProcfs ftrace(kTracingPath);
std::string format = ftrace.ReadEventFormat("ftrace", "print");
EXPECT_THAT(format, HasSubstr("name: print"));
EXPECT_THAT(format, HasSubstr("field:char buf"));
}
-TEST(FtraceProcfsIntegrationTest, ReadAvailableEvents) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_ReadAvailableEvents) {
FtraceProcfs ftrace(kTracingPath);
std::string format = ftrace.ReadAvailableEvents();
EXPECT_THAT(format, HasSubstr("sched:sched_switch"));
}
-TEST(FtraceProcfsIntegrationTest, CanOpenTracePipeRaw) {
+TEST(FtraceProcfsIntegrationTest, DISABLED_CanOpenTracePipeRaw) {
FtraceProcfs ftrace(kTracingPath);
EXPECT_TRUE(ftrace.OpenPipeForCpu(0));
}
diff --git a/src/ipc/client_impl.cc b/src/ipc/client_impl.cc
index 9433ef9..77aa4f9 100644
--- a/src/ipc/client_impl.cc
+++ b/src/ipc/client_impl.cc
@@ -44,6 +44,8 @@
}
ClientImpl::~ClientImpl() {
+ // Ensure we are not destroyed in the middle of invoking a reply.
+ PERFETTO_DCHECK(!invoking_method_reply_);
OnDisconnect(nullptr); // The UnixSocket* ptr is not used in OnDisconnect().
}
@@ -241,8 +243,10 @@
}
}
const RequestID request_id = req.request_id;
+ invoking_method_reply_ = true;
service_proxy->EndInvoke(request_id, std::move(decoded_reply),
reply.has_more());
+ invoking_method_reply_ = false;
// If this is a streaming method and future replies will be resolved, put back
// the |req| with the callback into the set of active requests.
diff --git a/src/ipc/client_impl.h b/src/ipc/client_impl.h
index d8cceb1..4c43b16 100644
--- a/src/ipc/client_impl.h
+++ b/src/ipc/client_impl.h
@@ -79,6 +79,7 @@
void OnBindServiceReply(QueuedRequest, const Frame::BindServiceReply&);
void OnInvokeMethodReply(QueuedRequest, const Frame::InvokeMethodReply&);
+ bool invoking_method_reply_ = false;
std::unique_ptr<UnixSocket> sock_;
base::TaskRunner* const task_runner_;
RequestID last_request_id_ = 0;
diff --git a/src/traced/probes/ftrace_producer.cc b/src/traced/probes/ftrace_producer.cc
index 00ea48d..cf55d53 100644
--- a/src/traced/probes/ftrace_producer.cc
+++ b/src/traced/probes/ftrace_producer.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,7 +20,6 @@
#include <string>
#include "perfetto/base/logging.h"
-#include "perfetto/base/unix_task_runner.h"
#include "perfetto/traced/traced.h"
#include "perfetto/tracing/core/data_source_config.h"
#include "perfetto/tracing/core/data_source_descriptor.h"
@@ -94,14 +93,12 @@
delegates_.erase(id);
}
-void FtraceProducer::Run() {
- base::UnixTaskRunner task_runner;
- ftrace_ = FtraceController::Create(&task_runner);
- endpoint_ = ProducerIPCClient::Connect(PERFETTO_PRODUCER_SOCK_NAME, this,
- &task_runner);
+void FtraceProducer::Connect(const char* socket_name,
+ base::TaskRunner* task_runner) {
+ ftrace_ = FtraceController::Create(task_runner);
+ endpoint_ = ProducerIPCClient::Connect(socket_name, this, task_runner);
ftrace_->DisableAllEvents();
ftrace_->ClearTrace();
- task_runner.Run();
}
FtraceProducer::SinkDelegate::SinkDelegate(std::unique_ptr<TraceWriter> writer)
diff --git a/src/traced/probes/ftrace_producer.h b/src/traced/probes/ftrace_producer.h
index 32baf76..3f8c53b 100644
--- a/src/traced/probes/ftrace_producer.h
+++ b/src/traced/probes/ftrace_producer.h
@@ -18,6 +18,7 @@
#include <memory>
#include <utility>
+#include "perfetto/base/task_runner.h"
#include "perfetto/ftrace_reader/ftrace_controller.h"
#include "perfetto/tracing/core/producer.h"
#include "perfetto/tracing/core/trace_writer.h"
@@ -39,7 +40,7 @@
void TearDownDataSourceInstance(DataSourceInstanceID) override;
// Our Impl
- void Run();
+ void Connect(const char* socket_name, base::TaskRunner* task_runner);
private:
using BundleHandle =
diff --git a/src/traced/probes/probes.cc b/src/traced/probes/probes.cc
index 27e422a..d1fcacc 100644
--- a/src/traced/probes/probes.cc
+++ b/src/traced/probes/probes.cc
@@ -15,16 +15,19 @@
*/
#include "perfetto/base/logging.h"
+#include "perfetto/base/unix_task_runner.h"
#include "perfetto/traced/traced.h"
-#include "ftrace_producer.h"
+#include "src/traced/probes/ftrace_producer.h"
namespace perfetto {
int __attribute__((visibility("default"))) ProbesMain(int argc, char** argv) {
PERFETTO_LOG("Starting %s service", argv[0]);
+ base::UnixTaskRunner task_runner;
FtraceProducer producer;
- producer.Run();
+ producer.Connect(PERFETTO_PRODUCER_SOCK_NAME, &task_runner);
+ task_runner.Run();
return 0;
}
diff --git a/test/BUILD.gn b/test/BUILD.gn
new file mode 100644
index 0000000..266db1e
--- /dev/null
+++ b/test/BUILD.gn
@@ -0,0 +1,38 @@
+# Copyright (C) 2018 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build_overrides/build.gni")
+
+source_set("end_to_end_integrationtests") {
+ testonly = true
+ deps = [
+ "../gn:default_deps",
+ "../gn:gtest_deps",
+ "../protos/perfetto/trace:lite",
+ "../src/base:base",
+ "../src/base:test_support",
+ "../src/traced/probes:ftrace_producer",
+ "../src/tracing:ipc",
+ ]
+ sources = [
+ "end_to_end_integrationtest.cc",
+ "fake_consumer.cc",
+ "fake_consumer.h",
+ "fake_producer.cc",
+ "fake_producer.h",
+ ]
+ if (is_android && !build_with_chromium) {
+ deps += [ "../src/base:android_task_runner" ]
+ }
+}
diff --git a/test/end_to_end_integrationtest.cc b/test/end_to_end_integrationtest.cc
new file mode 100644
index 0000000..bf4ef6d
--- /dev/null
+++ b/test/end_to_end_integrationtest.cc
@@ -0,0 +1,310 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <thread>
+
+#include "perfetto/base/logging.h"
+#include "perfetto/trace/trace_packet.pb.h"
+#include "perfetto/trace/trace_packet.pbzero.h"
+#include "perfetto/traced/traced.h"
+#include "perfetto/tracing/core/consumer.h"
+#include "perfetto/tracing/core/trace_config.h"
+#include "perfetto/tracing/core/trace_packet.h"
+#include "perfetto/tracing/ipc/consumer_ipc_client.h"
+#include "perfetto/tracing/ipc/service_ipc_host.h"
+
+#include "src/base/test/test_task_runner.h"
+#include "src/traced/probes/ftrace_producer.h"
+#include "test/fake_consumer.h"
+#include "test/fake_producer.h"
+
+#if BUILDFLAG(PERFETTO_ANDROID_BUILD)
+#include "perfetto/base/android_task_runner.h"
+#endif
+
+namespace perfetto {
+
+#if BUILDFLAG(PERFETTO_ANDROID_BUILD)
+using PlatformTaskRunner = base::AndroidTaskRunner;
+#else
+using PlatformTaskRunner = base::UnixTaskRunner;
+#endif
+
+// If we're building on Android but not as a CTS test, create the the producer
+// and consumer socket in a world writable directory so permissions are not a
+// problem.
+#if BUILDFLAG(OS_ANDROID) && !BUILDFLAG(PERFETTO_ANDROID_BUILD)
+#define TEST_PRODUCER_SOCK_NAME "/data/local/tmp/traced_producer"
+#define TEST_CONSUMER_SOCK_NAME "/data/local/tmp/traced_consumer"
+#else
+#define TEST_PRODUCER_SOCK_NAME PERFETTO_PRODUCER_SOCK_NAME
+#define TEST_CONSUMER_SOCK_NAME PERFETTO_CONSUMER_SOCK_NAME
+#endif
+
+class PerfettoTest : public ::testing::Test {
+ public:
+ PerfettoTest() {}
+ ~PerfettoTest() override = default;
+
+ protected:
+ class ThreadDelegate {
+ public:
+ virtual ~ThreadDelegate() = default;
+
+ // Invoke on the target thread before the message loop is started.
+ virtual void Initialize(base::TaskRunner* task_runner) = 0;
+ };
+
+ class TaskRunnerThread {
+ public:
+ TaskRunnerThread() = default;
+ ~TaskRunnerThread() {
+ {
+ std::unique_lock<std::mutex> lock(mutex_);
+ if (runner_)
+ runner_->Quit();
+ }
+
+ if (thread_.joinable())
+ thread_.join();
+ }
+
+ // Blocks until the thread has been created and Initialize() has been
+ // called.
+ void Start(std::unique_ptr<ThreadDelegate> delegate) {
+ // Begin holding the lock for the condition variable.
+ std::unique_lock<std::mutex> lock(mutex_);
+
+ // Start the thread.
+ PERFETTO_DCHECK(!runner_);
+ thread_ = std::thread(&TaskRunnerThread::Run, this, std::move(delegate));
+
+ // Wait for runner to be ready.
+ ready_.wait_for(lock, std::chrono::seconds(10),
+ [this]() { return runner_ != nullptr; });
+ }
+
+ private:
+ void Run(std::unique_ptr<ThreadDelegate> delegate) {
+ // Create the task runner and execute the specicalised code.
+ base::PlatformTaskRunner task_runner;
+ delegate->Initialize(&task_runner);
+
+ // Pass the runner back to the main thread.
+ {
+ std::unique_lock<std::mutex> lock(mutex_);
+ runner_ = &task_runner;
+ }
+
+ // Notify the main thread that the runner is ready.
+ ready_.notify_one();
+
+ // Spin the loop.
+ task_runner.Run();
+
+ // Ensure we clear out the delegate before runner goes out
+ // of scope.
+ delegate.reset();
+
+ // Cleanup the runner.
+ {
+ std::unique_lock<std::mutex> lock(mutex_);
+ runner_ = nullptr;
+ }
+ }
+
+ std::thread thread_;
+ std::condition_variable ready_;
+
+ // All variables below this point are protected by |mutex_|.
+ std::mutex mutex_;
+ base::PlatformTaskRunner* runner_ = nullptr;
+ };
+
+ // This is used only in standalone integrations tests. In CTS mode (i.e. when
+ // PERFETTO_ANDROID_BUILD) this code is not used and instead the system
+ // daemons are used
+ class ServiceDelegate : public ThreadDelegate {
+ public:
+ ServiceDelegate() = default;
+ ~ServiceDelegate() override = default;
+
+ void Initialize(base::TaskRunner* task_runner) override {
+ svc_ = ServiceIPCHost::CreateInstance(task_runner);
+ unlink(TEST_PRODUCER_SOCK_NAME);
+ unlink(TEST_CONSUMER_SOCK_NAME);
+ svc_->Start(TEST_PRODUCER_SOCK_NAME, TEST_CONSUMER_SOCK_NAME);
+ }
+
+ private:
+ std::unique_ptr<ServiceIPCHost> svc_;
+ };
+
+ // This is used only in standalone integrations tests. In CTS mode (i.e. when
+ // PERFETTO_ANDROID_BUILD) this code is not used and instead the system
+ // daemons are used.
+ class FtraceProducerDelegate : public ThreadDelegate {
+ public:
+ FtraceProducerDelegate() = default;
+ ~FtraceProducerDelegate() override = default;
+
+ void Initialize(base::TaskRunner* task_runner) override {
+ producer_.reset(new FtraceProducer);
+ producer_->Connect(TEST_PRODUCER_SOCK_NAME, task_runner);
+ }
+
+ private:
+ std::unique_ptr<FtraceProducer> producer_;
+ };
+
+ class FakeProducerDelegate : public ThreadDelegate {
+ public:
+ FakeProducerDelegate() = default;
+ ~FakeProducerDelegate() override = default;
+
+ void Initialize(base::TaskRunner* task_runner) override {
+ producer_.reset(new FakeProducer("android.perfetto.FakeProducer"));
+ producer_->Connect(TEST_PRODUCER_SOCK_NAME, task_runner);
+ }
+
+ private:
+ std::unique_ptr<FakeProducer> producer_;
+ };
+};
+
+// TODO(lalitm): reenable this when we have a solution for running ftrace
+// on travis.
+TEST_F(PerfettoTest, DISABLED_TestFtraceProducer) {
+ base::TestTaskRunner task_runner;
+ auto finish = task_runner.CreateCheckpoint("no.more.packets");
+
+ // Setip the TraceConfig for the consumer.
+ TraceConfig trace_config;
+ trace_config.add_buffers()->set_size_kb(4096 * 10);
+ trace_config.set_duration_ms(200);
+
+ // Create the buffer for ftrace.
+ auto* ds_config = trace_config.add_data_sources()->mutable_config();
+ ds_config->set_name("com.google.perfetto.ftrace");
+ ds_config->set_target_buffer(0);
+
+ // Setup the config for ftrace.
+ auto* ftrace_config = ds_config->mutable_ftrace_config();
+ *ftrace_config->add_event_names() = "sched_switch";
+ *ftrace_config->add_event_names() = "bar";
+
+ // Create the function to handle packets as they come in.
+ uint64_t total = 0;
+ auto function = [&total, &finish](std::vector<TracePacket> packets,
+ bool has_more) {
+ if (has_more) {
+ for (auto& packet : packets) {
+ packet.Decode();
+ ASSERT_TRUE(packet->has_ftrace_events());
+ for (int ev = 0; ev < packet->ftrace_events().event_size(); ev++) {
+ ASSERT_TRUE(packet->ftrace_events().event(ev).has_sched_switch());
+ }
+ }
+ total += packets.size();
+
+ // TODO(lalitm): renable this when stiching inside the service is present.
+ // ASSERT_FALSE(packets->empty());
+ } else {
+ ASSERT_GE(total, static_cast<uint64_t>(sysconf(_SC_NPROCESSORS_CONF)));
+ ASSERT_TRUE(packets.empty());
+ finish();
+ }
+ };
+
+// If we're building with the Android platform (i.e. CTS), we expect that
+// the service and ftrace producer both exist and are already running.
+// TODO(lalitm): maybe add an additional build flag for CTS.
+#if !BUILDFLAG(PERFETTO_ANDROID_BUILD)
+ TaskRunnerThread service_thread;
+ service_thread.Start(std::unique_ptr<ServiceDelegate>(new ServiceDelegate));
+
+ TaskRunnerThread producer_thread;
+ producer_thread.Start(
+ std::unique_ptr<FtraceProducerDelegate>(new FtraceProducerDelegate));
+#endif
+
+ // Finally, make the consumer connect to the service.
+ FakeConsumer consumer(trace_config, std::move(function), &task_runner);
+ consumer.Connect(TEST_CONSUMER_SOCK_NAME);
+
+ task_runner.RunUntilCheckpoint("no.more.packets");
+}
+
+TEST_F(PerfettoTest, TestFakeProducer) {
+ base::TestTaskRunner task_runner;
+ auto finish = task_runner.CreateCheckpoint("no.more.packets");
+
+ // Setip the TraceConfig for the consumer.
+ TraceConfig trace_config;
+ trace_config.add_buffers()->set_size_kb(4096 * 10);
+ trace_config.set_duration_ms(200);
+
+ // Create the buffer for ftrace.
+ auto* ds_config = trace_config.add_data_sources()->mutable_config();
+ ds_config->set_name("android.perfetto.FakeProducer");
+ ds_config->set_target_buffer(0);
+
+ // Create the function to handle packets as they come in.
+ uint64_t total = 0;
+ auto function = [&total, &finish](std::vector<TracePacket> packets,
+ bool has_more) {
+ if (has_more) {
+ for (auto& packet : packets) {
+ packet.Decode();
+ ASSERT_TRUE(packet->has_test());
+ ASSERT_EQ(packet->test(), "test");
+ }
+ total += packets.size();
+
+ // TODO(lalitm): renable this when stiching inside the service is present.
+ // ASSERT_FALSE(packets->empty());
+ } else {
+ ASSERT_EQ(total, 10u);
+ ASSERT_TRUE(packets.empty());
+ finish();
+ }
+ };
+
+// If we're building with the Android platform (i.e. CTS), we expect that
+// the service and ftrace producer both exist and are already running.
+// TODO(lalitm): maybe add an additional build flag for CTS.
+#if !BUILDFLAG(PERFETTO_ANDROID_BUILD)
+ TaskRunnerThread service_thread;
+ service_thread.Start(std::unique_ptr<ServiceDelegate>(new ServiceDelegate));
+
+ TaskRunnerThread producer_thread;
+ producer_thread.Start(
+ std::unique_ptr<FakeProducerDelegate>(new FakeProducerDelegate));
+#endif
+
+ // Finally, make the consumer connect to the service.
+ FakeConsumer consumer(trace_config, std::move(function), &task_runner);
+ consumer.Connect(TEST_CONSUMER_SOCK_NAME);
+
+ task_runner.RunUntilCheckpoint("no.more.packets");
+}
+
+} // namespace perfetto
diff --git a/test/fake_consumer.cc b/test/fake_consumer.cc
new file mode 100644
index 0000000..3347502
--- /dev/null
+++ b/test/fake_consumer.cc
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test/fake_consumer.h"
+
+#include <gtest/gtest.h>
+#include <utility>
+#include <vector>
+
+#include "perfetto/base/logging.h"
+#include "perfetto/trace/test_event.pbzero.h"
+#include "perfetto/trace/trace_packet.pbzero.h"
+#include "perfetto/traced/traced.h"
+#include "perfetto/tracing/core/trace_packet.h"
+#include "perfetto/tracing/core/trace_writer.h"
+
+namespace perfetto {
+
+FakeConsumer::FakeConsumer(
+ const TraceConfig& trace_config,
+ std::function<void(std::vector<TracePacket>, bool)> packet_callback,
+ base::TaskRunner* task_runner)
+ : packet_callback_(std::move(packet_callback)),
+ trace_config_(trace_config),
+ task_runner_(task_runner) {}
+FakeConsumer::~FakeConsumer() = default;
+
+void FakeConsumer::Connect(const char* socket_name) {
+ endpoint_ = ConsumerIPCClient::Connect(socket_name, this, task_runner_);
+}
+
+void FakeConsumer::OnConnect() {
+ endpoint_->EnableTracing(trace_config_);
+ task_runner_->PostDelayedTask(std::bind([this]() {
+ endpoint_->DisableTracing();
+ endpoint_->ReadBuffers();
+ }),
+ trace_config_.duration_ms());
+}
+
+void FakeConsumer::OnDisconnect() {
+ FAIL() << "Disconnected from service unexpectedly";
+}
+
+void FakeConsumer::OnTraceData(std::vector<TracePacket> data, bool has_more) {
+ packet_callback_(std::move(data), has_more);
+}
+
+} // namespace perfetto
diff --git a/test/fake_consumer.h b/test/fake_consumer.h
new file mode 100644
index 0000000..cad7ee0
--- /dev/null
+++ b/test/fake_consumer.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TEST_FAKE_CONSUMER_H_
+#define TEST_FAKE_CONSUMER_H_
+
+#include <memory>
+#include <vector>
+
+#include "perfetto/tracing/core/consumer.h"
+#include "perfetto/tracing/core/trace_config.h"
+#include "perfetto/tracing/core/trace_packet.h"
+#include "perfetto/tracing/ipc/consumer_ipc_client.h"
+
+#include "src/base/test/test_task_runner.h"
+
+namespace perfetto {
+
+class FakeConsumer : public Consumer {
+ public:
+ FakeConsumer(
+ const TraceConfig& trace_config,
+ std::function<void(std::vector<TracePacket>, bool)> packet_callback,
+ base::TaskRunner* task_runner);
+ ~FakeConsumer() override;
+
+ void Connect(const char* socket_name);
+
+ // Consumer implementation.
+ void OnConnect() override;
+ void OnDisconnect() override;
+ void OnTraceData(std::vector<TracePacket> packets, bool has_more) override;
+
+ private:
+ std::function<void(std::vector<TracePacket>, bool)> packet_callback_;
+ std::unique_ptr<Service::ConsumerEndpoint> endpoint_;
+ const TraceConfig trace_config_;
+ base::TaskRunner* const task_runner_;
+};
+
+} // namespace perfetto
+
+#endif // TEST_FAKE_CONSUMER_H_
diff --git a/test/fake_producer.cc b/test/fake_producer.cc
new file mode 100644
index 0000000..e335bea
--- /dev/null
+++ b/test/fake_producer.cc
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test/fake_producer.h"
+
+#include "perfetto/base/logging.h"
+#include "perfetto/trace/test_event.pbzero.h"
+#include "perfetto/trace/trace_packet.pbzero.h"
+#include "perfetto/traced/traced.h"
+#include "perfetto/tracing/core/trace_config.h"
+#include "perfetto/tracing/core/trace_packet.h"
+#include "perfetto/tracing/core/trace_writer.h"
+
+namespace perfetto {
+
+FakeProducer::FakeProducer(const std::string& name) : name_(name) {}
+FakeProducer::~FakeProducer() = default;
+
+void FakeProducer::Connect(const char* socket_name,
+ base::TaskRunner* task_runner) {
+ endpoint_ = ProducerIPCClient::Connect(socket_name, this, task_runner);
+}
+
+void FakeProducer::OnConnect() {
+ DataSourceDescriptor descriptor;
+ descriptor.set_name(name_);
+ endpoint_->RegisterDataSource(descriptor,
+ [this](DataSourceID id) { id_ = id; });
+}
+
+void FakeProducer::OnDisconnect() {}
+
+void FakeProducer::CreateDataSourceInstance(
+ DataSourceInstanceID,
+ const DataSourceConfig& source_config) {
+ auto trace_writer = endpoint_->CreateTraceWriter(
+ static_cast<BufferID>(source_config.target_buffer()));
+ for (int i = 0; i < 10; i++) {
+ auto handle = trace_writer->NewTracePacket();
+ handle->set_test("test");
+ handle->Finalize();
+ }
+
+ // Temporarily create a new packet to flush the final packet to the
+ // consumer.
+ // TODO(primiano): remove this hack once flushing the final packet is fixed.
+ trace_writer->NewTracePacket();
+
+ // TODO(primiano): reenable this once UnregisterDataSource is specified in
+ // ServiceImpl.
+ // endpoint_->UnregisterDataSource(id_);
+}
+
+void FakeProducer::TearDownDataSourceInstance(DataSourceInstanceID) {}
+
+} // namespace perfetto
diff --git a/test/fake_producer.h b/test/fake_producer.h
new file mode 100644
index 0000000..5b61468
--- /dev/null
+++ b/test/fake_producer.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TEST_FAKE_PRODUCER_H_
+#define TEST_FAKE_PRODUCER_H_
+
+#include <memory>
+#include <string>
+
+#include "perfetto/tracing/core/data_source_descriptor.h"
+#include "perfetto/tracing/core/producer.h"
+#include "perfetto/tracing/ipc/producer_ipc_client.h"
+
+#include "src/base/test/test_task_runner.h"
+
+namespace perfetto {
+
+class FakeProducer : public Producer {
+ public:
+ explicit FakeProducer(const std::string& name);
+ ~FakeProducer() override;
+
+ void Connect(const char* socket_name, base::TaskRunner* task_runner);
+
+ // Producer implementation.
+ void OnConnect() override;
+ void OnDisconnect() override;
+ void CreateDataSourceInstance(DataSourceInstanceID,
+ const DataSourceConfig& source_config) override;
+ void TearDownDataSourceInstance(DataSourceInstanceID) override;
+
+ private:
+ void Shutdown();
+
+ std::string name_;
+ DataSourceID id_ = 0;
+ std::unique_ptr<Service::ProducerEndpoint> endpoint_;
+};
+
+} // namespace perfetto
+
+#endif // TEST_FAKE_PRODUCER_H_
diff --git a/tools/gen_android_bp b/tools/gen_android_bp
index b2c4c0f..8cb7e39 100755
--- a/tools/gen_android_bp
+++ b/tools/gen_android_bp
@@ -37,7 +37,8 @@
# Default targets to translate to the blueprint file.
default_targets = [
'//:libtraced_shared',
- '//:perfetto_tests',
+ '//:perfetto_integrationtests',
+ '//:perfetto_unittests',
'//:perfetto',
'//:traced',
'//:traced_probes',
diff --git a/tools/run_android_test b/tools/run_android_test
index 95d7cab..b34408e 100755
--- a/tools/run_android_test
+++ b/tools/run_android_test
@@ -115,7 +115,7 @@
parser.add_argument('--no-cleanup', '-n', action='store_true')
parser.add_argument('--no-data-deps', '-x', action='store_true')
parser.add_argument('out_dir', help='out/android/')
- parser.add_argument('test_name', help='perfetto_tests')
+ parser.add_argument('test_name', help='perfetto_unittests')
parser.add_argument('cmd_args', nargs=argparse.REMAINDER)
args = parser.parse_args()
@@ -125,6 +125,8 @@
print 'Waiting for device ...'
AdbCall('wait-for-device')
WaitForBootCompletion()
+ AdbCall('root')
+ AdbCall('wait-for-device')
target_dir = '/data/local/tmp/' + args.test_name
AdbCall('shell', 'rm -rf "%s"; mkdir -p "%s"' % (2 * (target_dir,)))