Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright (C) 2016, 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 <cerrno>
     18 #include <memory>
     19 #include <tuple>
     20 #include <utility>
     21 
     22 #include "gmock/gmock.h"
     23 #include "gtest/gtest.h"
     24 
     25 #include "wifilogd/tests/mock_command_processor.h"
     26 #include "wifilogd/tests/mock_os.h"
     27 
     28 #include "wifilogd/main_loop.h"
     29 #include "wifilogd/protocol.h"
     30 
     31 namespace android {
     32 namespace wifilogd {
     33 namespace {
     34 
     35 using ::testing::_;
     36 using ::testing::AnyNumber;
     37 using ::testing::Ge;
     38 using ::testing::Return;
     39 using ::testing::StrictMock;
     40 
     41 constexpr int kControlSocketFd = 100;
     42 constexpr char kFakeSocketName[] = "fake-socket";
     43 
     44 class MainLoopTest : public ::testing::Test {
     45  public:
     46   MainLoopTest()
     47       : os_(new StrictMock<MockOs>()),
     48         command_processor_(new StrictMock<MockCommandProcessor>()) {
     49     EXPECT_CALL(*os_, GetControlSocket(kFakeSocketName))
     50         .WillOnce(Return(std::tuple<size_t, Os::Errno>{kControlSocketFd, 0}));
     51     main_loop_ = std::make_unique<MainLoop>(
     52         kFakeSocketName, std::unique_ptr<Os>{os_},
     53         std::unique_ptr<CommandProcessor>{command_processor_});
     54   }
     55 
     56  protected:
     57   std::unique_ptr<MainLoop> main_loop_;
     58   // We use raw pointers to access the mocks, since ownership passes
     59   // to |main_loop_|.
     60   StrictMock<MockOs>* os_;
     61   StrictMock<MockCommandProcessor>* command_processor_;
     62 };
     63 
     64 }  // namespace
     65 
     66 TEST_F(MainLoopTest, RunOnceReadsFromCorrectSocket) {
     67   EXPECT_CALL(*os_, ReceiveDatagram(kControlSocketFd, _, _));
     68   EXPECT_CALL(*command_processor_, ProcessCommand(_, _, _)).Times(AnyNumber());
     69   main_loop_->RunOnce();
     70 }
     71 
     72 TEST_F(MainLoopTest, RunOnceReadsWithSufficientlyLargeBuffer) {
     73   EXPECT_CALL(*os_, ReceiveDatagram(_, _, Ge(protocol::kMaxMessageSize)));
     74   EXPECT_CALL(*command_processor_, ProcessCommand(_, _, _)).Times(AnyNumber());
     75   main_loop_->RunOnce();
     76 }
     77 
     78 TEST_F(MainLoopTest, RunOncePassesSmallestValidMessageToCommandProcessor) {
     79   EXPECT_CALL(*os_, ReceiveDatagram(_, _, _))
     80       .WillOnce(
     81           Return(std::tuple<size_t, Os::Errno>{sizeof(protocol::Command), 0}));
     82   EXPECT_CALL(*command_processor_,
     83               ProcessCommand(_, sizeof(protocol::Command), _));
     84   main_loop_->RunOnce();
     85 }
     86 
     87 TEST_F(MainLoopTest, RunOncePassesLargestValidMessageToCommandProcessor) {
     88   EXPECT_CALL(*os_, ReceiveDatagram(_, _, _))
     89       .WillOnce(
     90           Return(std::tuple<size_t, Os::Errno>{protocol::kMaxMessageSize, 0}));
     91   EXPECT_CALL(*command_processor_,
     92               ProcessCommand(_, protocol::kMaxMessageSize, _));
     93   main_loop_->RunOnce();
     94 }
     95 
     96 TEST_F(MainLoopTest, RunOncePassesRuntMessageToCommandProcessor) {
     97   EXPECT_CALL(*os_, ReceiveDatagram(_, _, _))
     98       .WillOnce(Return(std::tuple<size_t, Os::Errno>{0, 0}));
     99   EXPECT_CALL(*command_processor_, ProcessCommand(_, 0, _));
    100   main_loop_->RunOnce();
    101 }
    102 
    103 TEST_F(MainLoopTest, RunOnceLimitsMaxSizeReportedToCommandProcessor) {
    104   EXPECT_CALL(*os_, ReceiveDatagram(_, _, _))
    105       .WillOnce(Return(
    106           std::tuple<size_t, Os::Errno>{protocol::kMaxMessageSize + 1, 0}));
    107   EXPECT_CALL(*command_processor_,
    108               ProcessCommand(_, protocol::kMaxMessageSize, _));
    109   main_loop_->RunOnce();
    110 }
    111 
    112 TEST_F(MainLoopTest, RunOnceSleepsAndDoesNotPassDataToCommandProcessorOnError) {
    113   EXPECT_CALL(*os_, ReceiveDatagram(_, _, protocol::kMaxMessageSize))
    114       .WillOnce(Return(std::tuple<size_t, Os::Errno>{0, EINTR}));
    115   EXPECT_CALL(*os_, Nanosleep(_));
    116   EXPECT_CALL(*command_processor_, ProcessCommand(_, _, _)).Times(0);
    117   main_loop_->RunOnce();
    118 }
    119 
    120 // Per
    121 // github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md#death-tests,
    122 // death tests should be specially named.
    123 using MainLoopDeathTest = MainLoopTest;
    124 
    125 TEST_F(MainLoopDeathTest, CtorFailureToFetchControlSocketCausesDeath) {
    126   auto os = std::make_unique<StrictMock<MockOs>>();
    127   auto command_processor = std::make_unique<StrictMock<MockCommandProcessor>>();
    128   ON_CALL(*os, GetControlSocket(kFakeSocketName))
    129       .WillByDefault(Return(std::tuple<size_t, Os::Errno>{-1, ERANGE}));
    130   EXPECT_DEATH(
    131       MainLoop(kFakeSocketName, std::move(os), std::move(command_processor)),
    132       "Failed to get control socket");
    133 }
    134 
    135 TEST_F(MainLoopDeathTest, RunOnceTerminatesOnUnexpectedError) {
    136   ON_CALL(*os_, ReceiveDatagram(_, _, protocol::kMaxMessageSize))
    137       .WillByDefault(Return(std::tuple<size_t, Os::Errno>{0, EFAULT}));
    138   EXPECT_DEATH(main_loop_->RunOnce(), "Unexpected error");
    139 }
    140 
    141 }  // namespace wifilogd
    142 }  // namespace android
    143