Home | History | Annotate | Download | only in test 
      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 "src/tracing/test/mock_producer.h"
     18 
     19 #include "perfetto/tracing/core/data_source_config.h"
     20 #include "perfetto/tracing/core/data_source_descriptor.h"
     21 #include "perfetto/tracing/core/trace_writer.h"
     22 #include "src/base/test/test_task_runner.h"
     23 
     24 using ::testing::_;
     25 using ::testing::Eq;
     26 using ::testing::Invoke;
     27 using ::testing::InvokeWithoutArgs;
     28 using ::testing::Property;
     29 
     30 namespace perfetto {
     31 
     32 MockProducer::MockProducer(base::TestTaskRunner* task_runner)
     33     : task_runner_(task_runner) {}
     34 
     35 MockProducer::~MockProducer() {
     36   if (!service_endpoint_)
     37     return;
     38   static int i = 0;
     39   auto checkpoint_name = "on_producer_disconnect_" + std::to_string(i++);
     40   auto on_disconnect = task_runner_->CreateCheckpoint(checkpoint_name);
     41   EXPECT_CALL(*this, OnDisconnect()).WillOnce(Invoke(on_disconnect));
     42   service_endpoint_.reset();
     43   task_runner_->RunUntilCheckpoint(checkpoint_name);
     44 }
     45 
     46 void MockProducer::Connect(Service* svc,
     47                            const std::string& producer_name,
     48                            uid_t uid,
     49                            size_t shared_memory_size_hint_bytes) {
     50   producer_name_ = producer_name;
     51   service_endpoint_ = svc->ConnectProducer(this, uid, producer_name,
     52                                            shared_memory_size_hint_bytes);
     53   auto checkpoint_name = "on_producer_connect_" + producer_name;
     54   auto on_connect = task_runner_->CreateCheckpoint(checkpoint_name);
     55   EXPECT_CALL(*this, OnConnect()).WillOnce(Invoke(on_connect));
     56   task_runner_->RunUntilCheckpoint(checkpoint_name);
     57 }
     58 
     59 void MockProducer::RegisterDataSource(const std::string& name) {
     60   DataSourceDescriptor ds_desc;
     61   ds_desc.set_name(name);
     62   service_endpoint_->RegisterDataSource(ds_desc);
     63 }
     64 
     65 void MockProducer::UnregisterDataSource(const std::string& name) {
     66   service_endpoint_->UnregisterDataSource(name);
     67 }
     68 
     69 void MockProducer::WaitForTracingSetup() {
     70   static int i = 0;
     71   auto checkpoint_name =
     72       "on_shmem_initialized_" + producer_name_ + "_" + std::to_string(i++);
     73   auto on_tracing_enabled = task_runner_->CreateCheckpoint(checkpoint_name);
     74   EXPECT_CALL(*this, OnTracingSetup()).WillOnce(Invoke(on_tracing_enabled));
     75   task_runner_->RunUntilCheckpoint(checkpoint_name);
     76 }
     77 
     78 void MockProducer::WaitForDataSourceStart(const std::string& name) {
     79   static int i = 0;
     80   auto checkpoint_name = "on_ds_start_" + name + "_" + std::to_string(i++);
     81   auto on_ds_start = task_runner_->CreateCheckpoint(checkpoint_name);
     82   EXPECT_CALL(*this, CreateDataSourceInstance(
     83                          _, Property(&DataSourceConfig::name, Eq(name))))
     84       .WillOnce(Invoke([on_ds_start, this](DataSourceInstanceID ds_id,
     85                                            const DataSourceConfig& cfg) {
     86         EXPECT_FALSE(data_source_instances_.count(cfg.name()));
     87         auto target_buffer = static_cast<BufferID>(cfg.target_buffer());
     88         data_source_instances_.emplace(cfg.name(),
     89                                        EnabledDataSource{ds_id, target_buffer});
     90         on_ds_start();
     91       }));
     92   task_runner_->RunUntilCheckpoint(checkpoint_name);
     93 }
     94 
     95 void MockProducer::WaitForDataSourceStop(const std::string& name) {
     96   static int i = 0;
     97   auto checkpoint_name = "on_ds_stop_" + name + "_" + std::to_string(i++);
     98   auto on_ds_stop = task_runner_->CreateCheckpoint(checkpoint_name);
     99   ASSERT_EQ(1u, data_source_instances_.count(name));
    100   DataSourceInstanceID ds_id = data_source_instances_[name].id;
    101   EXPECT_CALL(*this, TearDownDataSourceInstance(ds_id))
    102       .WillOnce(InvokeWithoutArgs(on_ds_stop));
    103   task_runner_->RunUntilCheckpoint(checkpoint_name);
    104   data_source_instances_.erase(name);
    105 }
    106 
    107 std::unique_ptr<TraceWriter> MockProducer::CreateTraceWriter(
    108     const std::string& data_source_name) {
    109   PERFETTO_DCHECK(data_source_instances_.count(data_source_name));
    110   BufferID buf_id = data_source_instances_[data_source_name].target_buffer;
    111   return service_endpoint_->CreateTraceWriter(buf_id);
    112 }
    113 
    114 void MockProducer::WaitForFlush(TraceWriter* writer_to_flush) {
    115   auto& expected_call = EXPECT_CALL(*this, Flush(_, _, _));
    116   if (!writer_to_flush)
    117     return;
    118   expected_call.WillOnce(
    119       Invoke([this, writer_to_flush](FlushRequestID flush_req_id,
    120                                      const DataSourceInstanceID*, size_t) {
    121         writer_to_flush->Flush();
    122         service_endpoint_->NotifyFlushComplete(flush_req_id);
    123       }));
    124 }
    125 
    126 }  // namespace perfetto
    127