test/aom_integer_test.cc

   1 /*
   2  * Copyright (c) 2018, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11 #include <stdint.h>
  12
  13 #include "aom/aom_integer.h"
  14 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  15
  16 namespace {
  17 const uint64_t kMaximumLeb128CodedSize = 8;
  18 const uint8_t kLeb128PadByte = 0x80;                    // Binary: 10000000
  19 const uint64_t kMaximumLeb128Value = 0xFFFFFFFFFFFFFF;  // 2 ^ 56 - 1
  20 const uint32_t kSizeTestNumValues = 6;
  21 const uint32_t kSizeTestExpectedSizes[kSizeTestNumValues] = {
  22   1, 1, 2, 3, 4, 5
  23 };
  24 const uint64_t kSizeTestInputs[kSizeTestNumValues] = {
  25   0, 0x7f, 0x3fff, 0x1fffff, 0xffffff, 0x10000000
  26 };
  27 }  // namespace
  28
  29 TEST(AomLeb128, DecodeTest) {
  30   const size_t num_leb128_bytes = 3;
  31   const uint8_t leb128_bytes[num_leb128_bytes] = { 0xE5, 0x8E, 0x26 };
  32   const uint64_t expected_value = 0x98765;  // 624485
  33   const size_t expected_length = 3;
  34   uint64_t value = ~0ULL;  // make sure value is cleared by the function
  35   size_t length;
  36   ASSERT_EQ(
  37       aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes, &value, &length), 0);
  38   ASSERT_EQ(expected_value, value);
  39   ASSERT_EQ(expected_length, length);
  40
  41   // Make sure the decoder stops on the last marked LEB128 byte.
  42   aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes + 1, &value, &length);
  43   ASSERT_EQ(expected_value, value);
  44   ASSERT_EQ(expected_length, length);
  45 }
  46
  47 TEST(AomLeb128, EncodeTest) {
  48   const uint32_t test_value = 0x98765;  // 624485
  49   const uint8_t expected_bytes[3] = { 0xE5, 0x8E, 0x26 };
  50   const size_t kWriteBufferSize = 4;
  51   uint8_t write_buffer[kWriteBufferSize] = { 0 };
  52   size_t bytes_written = 0;
  53   ASSERT_EQ(aom_uleb_encode(test_value, kWriteBufferSize, &write_buffer[0],
  54                             &bytes_written),
  55             0);
  56   ASSERT_EQ(bytes_written, 3u);
  57   for (size_t i = 0; i < bytes_written; ++i) {
  58     ASSERT_EQ(write_buffer[i], expected_bytes[i]);
  59   }
  60 }
  61
  62 TEST(AomLeb128, EncodeDecodeTest) {
  63   const uint32_t value = 0x98765;  // 624485
  64   const size_t kWriteBufferSize = 4;
  65   uint8_t write_buffer[kWriteBufferSize] = { 0 };
  66   size_t bytes_written = 0;
  67   ASSERT_EQ(aom_uleb_encode(value, kWriteBufferSize, &write_buffer[0],
  68                             &bytes_written),
  69             0);
  70   ASSERT_EQ(bytes_written, 3u);
  71   uint64_t decoded_value;
  72   size_t decoded_length;
  73   aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value,
  74                   &decoded_length);
  75   ASSERT_EQ(value, decoded_value);
  76   ASSERT_EQ(bytes_written, decoded_length);
  77 }
  78
  79 TEST(AomLeb128, FixedSizeEncodeTest) {
  80   const uint32_t test_value = 0x123;
  81   const uint8_t expected_bytes[4] = { 0xa3, 0x82, 0x80, 0x00 };
  82   const size_t kWriteBufferSize = 4;
  83   uint8_t write_buffer[kWriteBufferSize] = { 0 };
  84   size_t bytes_written = 0;
  85   ASSERT_EQ(0, aom_uleb_encode_fixed_size(test_value, kWriteBufferSize,
  86                                           kWriteBufferSize, &write_buffer[0],
  87                                           &bytes_written));
  88   ASSERT_EQ(kWriteBufferSize, bytes_written);
  89   for (size_t i = 0; i < bytes_written; ++i) {
  90     ASSERT_EQ(write_buffer[i], expected_bytes[i]);
  91   }
  92 }
  93
  94 TEST(AomLeb128, FixedSizeEncodeDecodeTest) {
  95   const uint32_t value = 0x1;
  96   const size_t kWriteBufferSize = 4;
  97   uint8_t write_buffer[kWriteBufferSize] = { 0 };
  98   size_t bytes_written = 0;
  99   ASSERT_EQ(
 100       aom_uleb_encode_fixed_size(value, kWriteBufferSize, kWriteBufferSize,
 101                                  &write_buffer[0], &bytes_written),
 102       0);
 103   ASSERT_EQ(bytes_written, 4u);
 104   uint64_t decoded_value;
 105   size_t decoded_length;
 106   aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value,
 107                   &decoded_length);
 108   ASSERT_EQ(value, decoded_value);
 109   ASSERT_EQ(bytes_written, decoded_length);
 110 }
 111
 112 TEST(AomLeb128, SizeTest) {
 113   for (size_t i = 0; i < kSizeTestNumValues; ++i) {
 114     ASSERT_EQ(kSizeTestExpectedSizes[i],
 115               aom_uleb_size_in_bytes(kSizeTestInputs[i]));
 116   }
 117 }
 118
 119 TEST(AomLeb128, DecodeFailTest) {
 120   // Input buffer containing what would be a valid 9 byte LEB128 encoded
 121   // unsigned integer.
 122   const uint8_t kAllPadBytesBuffer[kMaximumLeb128CodedSize + 1] = {
 123     kLeb128PadByte, kLeb128PadByte, kLeb128PadByte,
 124     kLeb128PadByte, kLeb128PadByte, kLeb128PadByte,
 125     kLeb128PadByte, kLeb128PadByte, 0
 126   };
 127   uint64_t decoded_value;
 128
 129   // Test that decode fails when result would be valid 9 byte integer.
 130   ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize + 1,
 131                             &decoded_value, NULL),
 132             -1);
 133
 134   // Test that encoded value missing terminator byte within available buffer
 135   // range causes decode error.
 136   ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize,
 137                             &decoded_value, NULL),
 138             -1);
 139 }
 140
 141 TEST(AomLeb128, EncodeFailTest) {
 142   const size_t kWriteBufferSize = 4;
 143   const uint32_t kValidTestValue = 1;
 144   uint8_t write_buffer[kWriteBufferSize] = { 0 };
 145   size_t coded_size = 0;
 146   ASSERT_EQ(
 147       aom_uleb_encode(kValidTestValue, kWriteBufferSize, NULL, &coded_size),
 148       -1);
 149   ASSERT_EQ(aom_uleb_encode(kValidTestValue, kWriteBufferSize, &write_buffer[0],
 150                             NULL),
 151             -1);
 152
 153   const uint32_t kValueOutOfRangeForBuffer = 0xFFFFFFFF;
 154   ASSERT_EQ(aom_uleb_encode(kValueOutOfRangeForBuffer, kWriteBufferSize,
 155                             &write_buffer[0], &coded_size),
 156             -1);
 157
 158   const uint64_t kValueOutOfRange = kMaximumLeb128Value + 1;
 159   ASSERT_EQ(aom_uleb_encode(kValueOutOfRange, kWriteBufferSize,
 160                             &write_buffer[0], &coded_size),
 161             -1);
 162
 163   const size_t kPadSizeOutOfRange = 5;
 164   ASSERT_EQ(aom_uleb_encode_fixed_size(kValidTestValue, kWriteBufferSize,
 165                                        kPadSizeOutOfRange, &write_buffer[0],
 166                                        &coded_size),
 167             -1);
 168 }