1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "test/test_helper.h" 18 19 #include "gtest/gtest.h" 20 #include "perfetto/traced/traced.h" 21 #include "perfetto/tracing/core/trace_packet.h" 22 #include "test/task_runner_thread_delegates.h" 23 24 #include "src/tracing/ipc/default_socket.h" 25 26 #include "perfetto/trace/trace_packet.pb.h" 27 #include "perfetto/trace/trace_packet.pbzero.h" 28 29 namespace perfetto { 30 31 uint64_t TestHelper::next_instance_num_ = 0; 32 33 // If we're building on Android and starting the daemons ourselves, 34 // create the sockets in a world-writable location. 35 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \ 36 PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) 37 #define TEST_PRODUCER_SOCK_NAME "/data/local/tmp/traced_producer" 38 #define TEST_CONSUMER_SOCK_NAME "/data/local/tmp/traced_consumer" 39 #else 40 #define TEST_PRODUCER_SOCK_NAME ::perfetto::GetProducerSocket() 41 #define TEST_CONSUMER_SOCK_NAME ::perfetto::GetConsumerSocket() 42 #endif 43 44 TestHelper::TestHelper(base::TestTaskRunner* task_runner) 45 : instance_num_(next_instance_num_++), 46 task_runner_(task_runner), 47 service_thread_("perfetto.svc"), 48 producer_thread_("perfetto.prd") {} 49 50 void TestHelper::OnConnect() { 51 std::move(on_connect_callback_)(); 52 } 53 54 void TestHelper::OnDisconnect() { 55 FAIL() << "Consumer unexpectedly disconnected from the service"; 56 } 57 58 void TestHelper::OnTracingDisabled() { 59 std::move(on_stop_tracing_callback_)(); 60 } 61 62 void TestHelper::OnTraceData(std::vector<TracePacket> packets, bool has_more) { 63 for (auto& encoded_packet : packets) { 64 protos::TracePacket packet; 65 ASSERT_TRUE(encoded_packet.Decode(&packet)); 66 if (packet.has_clock_snapshot() || packet.has_trace_config() || 67 packet.has_trace_stats() || !packet.synchronization_marker().empty() || 68 packet.has_system_info()) { 69 continue; 70 } 71 ASSERT_EQ(protos::TracePacket::kTrustedUid, 72 packet.optional_trusted_uid_case()); 73 trace_.push_back(std::move(packet)); 74 } 75 76 if (!has_more) { 77 std::move(on_packets_finished_callback_)(); 78 } 79 } 80 81 void TestHelper::StartServiceIfRequired() { 82 #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) 83 service_thread_.Start(std::unique_ptr<ServiceDelegate>( 84 new ServiceDelegate(TEST_PRODUCER_SOCK_NAME, TEST_CONSUMER_SOCK_NAME))); 85 #endif 86 } 87 88 FakeProducer* TestHelper::ConnectFakeProducer() { 89 std::unique_ptr<FakeProducerDelegate> producer_delegate( 90 new FakeProducerDelegate(TEST_PRODUCER_SOCK_NAME, 91 WrapTask(CreateCheckpoint("producer.setup")), 92 WrapTask(CreateCheckpoint("producer.enabled")))); 93 FakeProducerDelegate* producer_delegate_cached = producer_delegate.get(); 94 producer_thread_.Start(std::move(producer_delegate)); 95 return producer_delegate_cached->producer(); 96 } 97 98 void TestHelper::ConnectConsumer() { 99 cur_consumer_num_++; 100 on_connect_callback_ = CreateCheckpoint("consumer.connected." + 101 std::to_string(cur_consumer_num_)); 102 endpoint_ = 103 ConsumerIPCClient::Connect(TEST_CONSUMER_SOCK_NAME, this, task_runner_); 104 } 105 106 void TestHelper::DetachConsumer(const std::string& key) { 107 on_detach_callback_ = CreateCheckpoint("detach." + key); 108 endpoint_->Detach(key); 109 RunUntilCheckpoint("detach." + key); 110 endpoint_.reset(); 111 } 112 113 bool TestHelper::AttachConsumer(const std::string& key) { 114 bool success = false; 115 auto checkpoint = CreateCheckpoint("attach." + key); 116 on_attach_callback_ = [&success, checkpoint](bool s) { 117 success = s; 118 checkpoint(); 119 }; 120 endpoint_->Attach(key); 121 RunUntilCheckpoint("attach." + key); 122 return success; 123 } 124 125 void TestHelper::StartTracing(const TraceConfig& config, 126 base::ScopedFile file) { 127 trace_.clear(); 128 on_stop_tracing_callback_ = CreateCheckpoint("stop.tracing"); 129 endpoint_->EnableTracing(config, std::move(file)); 130 } 131 132 void TestHelper::DisableTracing() { 133 endpoint_->DisableTracing(); 134 } 135 136 void TestHelper::FlushAndWait(uint32_t timeout_ms) { 137 static int flush_num = 0; 138 std::string checkpoint_name = "flush." + std::to_string(flush_num++); 139 auto checkpoint = CreateCheckpoint(checkpoint_name); 140 endpoint_->Flush(timeout_ms, [checkpoint](bool) { checkpoint(); }); 141 RunUntilCheckpoint(checkpoint_name, timeout_ms + 1000); 142 } 143 144 void TestHelper::ReadData(uint32_t read_count) { 145 on_packets_finished_callback_ = 146 CreateCheckpoint("readback.complete." + std::to_string(read_count)); 147 endpoint_->ReadBuffers(); 148 } 149 150 void TestHelper::WaitForConsumerConnect() { 151 RunUntilCheckpoint("consumer.connected." + std::to_string(cur_consumer_num_)); 152 } 153 154 void TestHelper::WaitForProducerSetup() { 155 RunUntilCheckpoint("producer.setup"); 156 } 157 158 void TestHelper::WaitForProducerEnabled() { 159 RunUntilCheckpoint("producer.enabled"); 160 } 161 162 void TestHelper::WaitForTracingDisabled(uint32_t timeout_ms) { 163 RunUntilCheckpoint("stop.tracing", timeout_ms); 164 } 165 166 void TestHelper::WaitForReadData(uint32_t read_count) { 167 RunUntilCheckpoint("readback.complete." + std::to_string(read_count)); 168 } 169 170 std::function<void()> TestHelper::WrapTask( 171 const std::function<void()>& function) { 172 return [this, function] { task_runner_->PostTask(function); }; 173 } 174 175 void TestHelper::OnDetach(bool) { 176 if (on_detach_callback_) 177 std::move(on_detach_callback_)(); 178 } 179 180 void TestHelper::OnAttach(bool success, const TraceConfig&) { 181 if (on_attach_callback_) 182 std::move(on_attach_callback_)(success); 183 } 184 185 void TestHelper::OnTraceStats(bool, const TraceStats&) {} 186 187 void TestHelper::OnObservableEvents(const ObservableEvents&) {} 188 189 // static 190 const char* TestHelper::GetConsumerSocketName() { 191 return TEST_CONSUMER_SOCK_NAME; 192 } 193 194 // static 195 const char* TestHelper::GetProducerSocketName() { 196 return TEST_PRODUCER_SOCK_NAME; 197 } 198 199 } // namespace perfetto 200