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 <cstddef>
     18 #include <type_traits>
     19 
     20 #include "gtest/gtest.h"
     21 
     22 #include "wifilogd/protocol.h"
     23 
     24 namespace android {
     25 namespace wifilogd {
     26 
     27 // The protocol tests aim to provide friction against changes that
     28 // break byte-stream compatibility. Byte-stream compatibility is
     29 // important for two reasons:
     30 //     1. We need to support non-C++ clients. Those clients may use bindings
     31 //        that are implemented in their own language, rather than using a
     32 //        C or C++ client library.
     33 //     2. We need to maintain compatibility with older clients talking to
     34 //        newer versions of wifilogd.
     35 
     36 TEST(ProtocolTest, AsciiMessageChainingWorks) {
     37   using protocol::AsciiMessage;
     38   uint8_t tagLen = 3;
     39   uint16_t dataLen = 7;
     40   const auto ascii_message_header =
     41       AsciiMessage().set_tag_len(tagLen).set_data_len(dataLen);
     42   EXPECT_EQ(tagLen, ascii_message_header.tag_len);
     43   EXPECT_EQ(dataLen, ascii_message_header.data_len);
     44 }
     45 
     46 TEST(ProtocolTest, AsciiMessageNonChainingWorks) {
     47   using protocol::AsciiMessage;
     48   uint8_t tagLen = 3;
     49   uint16_t dataLen = 7;
     50   AsciiMessage ascii_message_header = AsciiMessage();
     51   ascii_message_header.set_tag_len(tagLen);
     52   ascii_message_header.set_data_len(dataLen);
     53   EXPECT_EQ(tagLen, ascii_message_header.tag_len);
     54   EXPECT_EQ(dataLen, ascii_message_header.data_len);
     55 }
     56 
     57 TEST(ProtocolTest, AsciiMessageLayoutIsUnchanged) {
     58   using protocol::AsciiMessage;
     59   ASSERT_TRUE(std::is_standard_layout<AsciiMessage>::value);
     60 
     61   EXPECT_EQ(0U, offsetof(AsciiMessage, data_len));
     62   EXPECT_EQ(2U, sizeof(AsciiMessage::data_len));
     63 
     64   EXPECT_EQ(2U, offsetof(AsciiMessage, tag_len));
     65   EXPECT_EQ(1U, sizeof(AsciiMessage::tag_len));
     66 
     67   EXPECT_EQ(3U, offsetof(AsciiMessage, severity));
     68   EXPECT_EQ(1U, sizeof(AsciiMessage::severity));
     69 
     70   EXPECT_EQ(4U, sizeof(AsciiMessage));
     71 }
     72 
     73 TEST(ProtocolTest, CommandLayoutIsUnchanged) {
     74   using protocol::Command;
     75   ASSERT_TRUE(std::is_standard_layout<Command>::value);
     76 
     77   EXPECT_EQ(0U, offsetof(Command, src_boottime_nsec));
     78   EXPECT_EQ(8U, sizeof(Command::src_boottime_nsec));
     79 
     80   EXPECT_EQ(8U, offsetof(Command, sequence_num));
     81   EXPECT_EQ(2U, sizeof(Command::sequence_num));
     82 
     83   EXPECT_EQ(10U, offsetof(Command, opcode));
     84   EXPECT_EQ(2U, sizeof(Command::opcode));
     85 
     86   EXPECT_EQ(12U, offsetof(Command, payload_len));
     87   EXPECT_EQ(2U, sizeof(Command::payload_len));
     88 
     89   // The |reserved| field fills out Command, in place of padding that
     90   // would otherwise be added by the compiler.
     91   EXPECT_EQ(14U, offsetof(Command, reserved));
     92   EXPECT_EQ(2U, sizeof(Command::reserved));
     93 
     94   EXPECT_EQ(16U, sizeof(Command));
     95 }
     96 
     97 TEST(ProtocolTest, MaxMessageSizeHasNotShrunk) {
     98   EXPECT_GE(protocol::kMaxMessageSize, 4096U);
     99 }
    100 
    101 TEST(ProtocolTest, MessageSeveritiesAreUnchanged) {
    102   using protocol::MessageSeverity;
    103   EXPECT_EQ(0U, static_cast<uint8_t>(MessageSeverity::kError));
    104   EXPECT_EQ(1U, static_cast<uint8_t>(MessageSeverity::kWarning));
    105   EXPECT_EQ(2U, static_cast<uint8_t>(MessageSeverity::kInformational));
    106   EXPECT_EQ(3U, static_cast<uint8_t>(MessageSeverity::kTrace));
    107   EXPECT_EQ(4U, static_cast<uint8_t>(MessageSeverity::kDump));
    108 }
    109 
    110 TEST(ProtocolTest, OpcodesAreUnchanged) {
    111   using protocol::Opcode;
    112   EXPECT_EQ(2U, sizeof(Opcode));
    113   EXPECT_EQ(0U, static_cast<uint16_t>(Opcode::kWriteAsciiMessage));
    114   EXPECT_EQ(0x20U, static_cast<uint16_t>(Opcode::kDumpBuffers));
    115 }
    116 
    117 }  // namespace wifilogd
    118 }  // namespace android
    119