src/type3_AndroidCloud/anbox-master/tests/anbox/common/binary_writer_tests.cpp

   1 /*
   2  * Copyright (C) 2017 Simon Fels <morphis@gravedo.de>
   3  *
   4  * This program is free software: you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 3, as published
   6  * by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranties of
  10  * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
  11  * PURPOSE.  See the GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17
  18 #include "anbox/common/binary_writer.h"
  19
  20 #include <gmock/gmock.h>
  21
  22 namespace ac = anbox::common;
  23
  24 using namespace ::testing;
  25
  26 TEST(BinaryWriter, WriteUint32) {
  27   std::vector<std::uint8_t> buffer;
  28   buffer.resize(sizeof(std::uint32_t) * 2);
  29   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  30
  31   writer.write_uint32(0x10);
  32   writer.write_uint32(0x3322);
  33
  34   ASSERT_EQ(writer.bytes_written(), 8);
  35   ASSERT_THAT(buffer, ElementsAre(0x10, 0x00, 0x00, 0x00, 0x22, 0x33, 0x00, 0x00));
  36 }
  37
  38 TEST(BinaryWriter, WriteUint32FailsWithExhaustedError) {
  39   std::vector<std::uint8_t> buffer;
  40   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  41   EXPECT_THROW(writer.write_uint32(0x11), std::out_of_range);
  42 }
  43
  44 TEST(BinaryWriter, WriteUint32WithChangedBinaryOrder) {
  45   std::vector<std::uint8_t> buffer;
  46   buffer.resize(sizeof(std::uint32_t));
  47   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  48
  49   writer.set_byte_order(ac::BinaryWriter::Order::Big);
  50   writer.write_uint32(0x11223344);
  51
  52   ASSERT_EQ(writer.bytes_written(), 4);
  53   ASSERT_THAT(buffer, ElementsAre(0x11, 0x22, 0x33, 0x44));
  54
  55   buffer.clear();
  56   buffer.resize(sizeof(std::uint32_t));
  57
  58   writer = ac::BinaryWriter(buffer.begin(), buffer.end());
  59
  60   writer.set_byte_order(ac::BinaryWriter::Order::Little);
  61   writer.write_uint32(0x11223344);
  62
  63   ASSERT_EQ(writer.bytes_written(), 4);
  64   ASSERT_THAT(buffer, ElementsAre(0x44, 0x33, 0x22, 0x11));
  65 }
  66
  67 TEST(BinaryWriter, WriteUint16) {
  68   std::vector<std::uint8_t> buffer;
  69   buffer.resize(sizeof(std::uint16_t) * 2);
  70   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  71
  72   writer.write_uint16(0x10);
  73   writer.write_uint16(0x3322);
  74
  75   ASSERT_EQ(writer.bytes_written(), 4);
  76   ASSERT_THAT(buffer, ElementsAre(0x10, 0x00, 0x22, 0x33));
  77 }
  78
  79 TEST(BinaryWriter, WriteUint16FailsWithExhaustedError) {
  80   std::vector<std::uint8_t> buffer;
  81   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  82   EXPECT_THROW(writer.write_uint16(0x11), std::out_of_range);
  83 }
  84
  85 TEST(BinaryWriter, WriteUint16WithChangedBinaryOrder) {
  86   std::vector<std::uint8_t> buffer;
  87   buffer.resize(sizeof(std::uint16_t));
  88   ac::BinaryWriter writer(buffer.begin(), buffer.end());
  89
  90   writer.set_byte_order(ac::BinaryWriter::Order::Big);
  91   writer.write_uint16(0x1122);
  92
  93   ASSERT_EQ(writer.bytes_written(), 2);
  94   ASSERT_THAT(buffer, ElementsAre(0x11, 0x22));
  95
  96   buffer.clear();
  97   buffer.resize(sizeof(std::uint16_t));
  98
  99   writer = ac::BinaryWriter(buffer.begin(), buffer.end());
 100
 101   writer.set_byte_order(ac::BinaryWriter::Order::Little);
 102   writer.write_uint16(0x1122);
 103
 104   ASSERT_EQ(writer.bytes_written(), 2);
 105   ASSERT_THAT(buffer, ElementsAre(0x22, 0x11));
 106 }
 107
 108 TEST(BinaryWriter, WriteString) {
 109   std::vector<std::uint8_t> buffer;
 110   buffer.resize(sizeof(std::uint8_t) * 4);
 111   ac::BinaryWriter writer(buffer.begin(), buffer.end());
 112
 113   writer.write_string("test", 4);
 114
 115   ASSERT_EQ(writer.bytes_written(), 4);
 116   ASSERT_THAT(buffer, ElementsAre(0x74, 0x65, 0x73, 0x74));
 117 }
 118
 119 TEST(BinaryWriter, WriteStringWithSize) {
 120   std::vector<std::uint8_t> buffer;
 121   buffer.resize(sizeof(std::uint8_t) * 6);
 122   ac::BinaryWriter writer(buffer.begin(), buffer.end());
 123
 124   writer.set_byte_order(ac::BinaryWriter::Order::Big);
 125
 126   writer.write_string_with_size("test");
 127
 128   ASSERT_EQ(writer.bytes_written(), 6);
 129   ASSERT_THAT(buffer, ElementsAre(0x00, 0x04, 0x74, 0x65, 0x73, 0x74));
 130 }