1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/toolkit/crashreporter/google-breakpad/src/common/byte_cursor_unittest.cc Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,776 @@
1.4 +// Copyright (c) 2010 Google Inc.
1.5 +// All rights reserved.
1.6 +//
1.7 +// Redistribution and use in source and binary forms, with or without
1.8 +// modification, are permitted provided that the following conditions are
1.9 +// met:
1.10 +//
1.11 +// * Redistributions of source code must retain the above copyright
1.12 +// notice, this list of conditions and the following disclaimer.
1.13 +// * Redistributions in binary form must reproduce the above
1.14 +// copyright notice, this list of conditions and the following disclaimer
1.15 +// in the documentation and/or other materials provided with the
1.16 +// distribution.
1.17 +// * Neither the name of Google Inc. nor the names of its
1.18 +// contributors may be used to endorse or promote products derived from
1.19 +// this software without specific prior written permission.
1.20 +//
1.21 +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1.22 +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
1.23 +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
1.24 +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
1.25 +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1.26 +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
1.27 +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
1.28 +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
1.29 +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1.30 +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
1.31 +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.32 +
1.33 +// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
1.34 +
1.35 +// byte_cursor_unittest.cc: Unit tests for google_breakpad::ByteBuffer
1.36 +// and google_breakpad::ByteCursor.
1.37 +
1.38 +#include <string>
1.39 +
1.40 +#include <string.h>
1.41 +
1.42 +#include "breakpad_googletest_includes.h"
1.43 +#include "common/byte_cursor.h"
1.44 +#include "common/using_std_string.h"
1.45 +
1.46 +using google_breakpad::ByteBuffer;
1.47 +using google_breakpad::ByteCursor;
1.48 +
1.49 +TEST(Buffer, SizeOfNothing) {
1.50 + uint8_t data[1];
1.51 + ByteBuffer buffer(data, 0);
1.52 + EXPECT_EQ(0U, buffer.Size());
1.53 +}
1.54 +
1.55 +TEST(Buffer, SizeOfSomething) {
1.56 + uint8_t data[10];
1.57 + ByteBuffer buffer(data, sizeof(data));
1.58 + EXPECT_EQ(10U, buffer.Size());
1.59 +}
1.60 +
1.61 +TEST(Extent, AvailableEmpty) {
1.62 + uint8_t data[1];
1.63 + ByteBuffer buffer(data, 0);
1.64 + ByteCursor cursor(&buffer);
1.65 + EXPECT_EQ(0U, cursor.Available());
1.66 +}
1.67 +
1.68 +TEST(Extent, AtEndEmpty) {
1.69 + uint8_t data[1];
1.70 + ByteBuffer buffer(data, 0);
1.71 + ByteCursor cursor(&buffer);
1.72 + EXPECT_TRUE(cursor.AtEnd());
1.73 +}
1.74 +
1.75 +TEST(Extent, AsBoolEmpty) {
1.76 + uint8_t data[1];
1.77 + ByteBuffer buffer(data, 0);
1.78 + ByteCursor cursor(&buffer);
1.79 + EXPECT_TRUE(cursor);
1.80 +}
1.81 +
1.82 +TEST(Extent, AvailableSome) {
1.83 + uint8_t data[10];
1.84 + ByteBuffer buffer(data, sizeof(data));
1.85 + ByteCursor cursor(&buffer);
1.86 + EXPECT_EQ(10U, cursor.Available());
1.87 +}
1.88 +
1.89 +TEST(Extent, AtEndSome) {
1.90 + uint8_t data[10];
1.91 + ByteBuffer buffer(data, sizeof(data));
1.92 + ByteCursor cursor(&buffer);
1.93 + EXPECT_FALSE(cursor.AtEnd());
1.94 + EXPECT_TRUE(cursor.Skip(sizeof(data)).AtEnd());
1.95 +}
1.96 +
1.97 +TEST(Extent, AsBoolSome) {
1.98 + uint8_t data[10];
1.99 + ByteBuffer buffer(data, sizeof(data));
1.100 + ByteCursor cursor(&buffer);
1.101 + EXPECT_TRUE(cursor);
1.102 + EXPECT_TRUE(cursor.Skip(sizeof(data)));
1.103 + EXPECT_FALSE(cursor.Skip(1));
1.104 +}
1.105 +
1.106 +TEST(Extent, Cursor) {
1.107 + uint8_t data[] = { 0xf7,
1.108 + 0x9f, 0xbe,
1.109 + 0x67, 0xfb, 0xd3, 0x58,
1.110 + 0x6f, 0x36, 0xde, 0xd1,
1.111 + 0x2a, 0x2a, 0x2a };
1.112 + ByteBuffer buffer(data, sizeof(data));
1.113 + ByteCursor cursor(&buffer);
1.114 +
1.115 + uint8_t a;
1.116 + uint16_t b;
1.117 + uint32_t c;
1.118 + uint32_t d;
1.119 + uint8_t stars[3];
1.120 +
1.121 + EXPECT_EQ(data + 0U, cursor.here());
1.122 +
1.123 + EXPECT_TRUE(cursor >> a);
1.124 + EXPECT_EQ(data + 1U, cursor.here());
1.125 +
1.126 + EXPECT_TRUE(cursor >> b);
1.127 + EXPECT_EQ(data + 3U, cursor.here());
1.128 +
1.129 + EXPECT_TRUE(cursor >> c);
1.130 + EXPECT_EQ(data + 7U, cursor.here());
1.131 +
1.132 + EXPECT_TRUE(cursor.Skip(4));
1.133 + EXPECT_EQ(data + 11U, cursor.here());
1.134 +
1.135 + EXPECT_TRUE(cursor.Read(stars, 3));
1.136 + EXPECT_EQ(data + 14U, cursor.here());
1.137 +
1.138 + EXPECT_FALSE(cursor >> d);
1.139 + EXPECT_EQ(data + 14U, cursor.here());
1.140 +}
1.141 +
1.142 +TEST(Extent, SetOffset) {
1.143 + uint8_t data[] = { 0x5c, 0x79, 0x8c, 0xd5 };
1.144 + ByteBuffer buffer(data, sizeof(data));
1.145 + ByteCursor cursor(&buffer);
1.146 +
1.147 + uint8_t a, b, c, d, e;
1.148 + EXPECT_TRUE(cursor >> a);
1.149 + EXPECT_EQ(0x5cU, a);
1.150 + EXPECT_EQ(data + 1U, cursor.here());
1.151 + EXPECT_TRUE(((cursor >> b).set_here(data + 3) >> c).set_here(data + 1)
1.152 + >> d >> e);
1.153 + EXPECT_EQ(0x79U, b);
1.154 + EXPECT_EQ(0xd5U, c);
1.155 + EXPECT_EQ(0x79U, d);
1.156 + EXPECT_EQ(0x8cU, e);
1.157 + EXPECT_EQ(data + 3U, cursor.here());
1.158 +}
1.159 +
1.160 +TEST(BigEndian, Signed1) {
1.161 + uint8_t data[] = { 0x00, 0x7f, 0x80, 0xff };
1.162 + ByteBuffer buffer(data, sizeof(data));
1.163 + ByteCursor cursor(&buffer);
1.164 + cursor.set_big_endian(true);
1.165 + int a, b, c, d, e;
1.166 + ASSERT_TRUE(cursor
1.167 + .Read(1, true, &a)
1.168 + .Read(1, true, &b)
1.169 + .Read(1, true, &c)
1.170 + .Read(1, true, &d));
1.171 + EXPECT_EQ(0, a);
1.172 + EXPECT_EQ(0x7f, b);
1.173 + EXPECT_EQ(-0x80, c);
1.174 + EXPECT_EQ(-1, d);
1.175 + EXPECT_TRUE(cursor.AtEnd());
1.176 + EXPECT_FALSE(cursor.Read(1, true, &e));
1.177 +}
1.178 +
1.179 +TEST(BigEndian, Signed2) {
1.180 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x80, 0x7f, 0xff,
1.181 + 0x80, 0x00, 0x80, 0x80, 0xff, 0xff,
1.182 + 0x39, 0xf1, 0x8a, 0xbc, 0x5a, 0xec };
1.183 + ByteBuffer buffer(data, sizeof(data));
1.184 + ByteCursor cursor(&buffer, true);
1.185 + int a, b, c, d, e, f, g, h, i, j;
1.186 + ASSERT_TRUE(cursor
1.187 + .Read(2, true, &a)
1.188 + .Read(2, true, &b)
1.189 + .Read(2, true, &c)
1.190 + .Read(2, true, &d)
1.191 + .Read(2, true, &e)
1.192 + .Read(2, true, &f)
1.193 + .Read(2, true, &g)
1.194 + .Read(2, true, &h)
1.195 + .Read(2, true, &i));
1.196 + EXPECT_EQ(0, a);
1.197 + EXPECT_EQ(0x80, b);
1.198 + EXPECT_EQ(0x7fff, c);
1.199 + EXPECT_EQ(-0x8000, d);
1.200 + EXPECT_EQ(-0x7f80, e);
1.201 + EXPECT_EQ(-1, f);
1.202 + EXPECT_EQ(0x39f1, g);
1.203 + EXPECT_EQ(-0x7544, h);
1.204 + EXPECT_EQ(0x5aec, i);
1.205 + EXPECT_TRUE(cursor.AtEnd());
1.206 + EXPECT_FALSE(cursor.Read(2, true, &j));
1.207 +}
1.208 +
1.209 +TEST(BigEndian, Signed4) {
1.210 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00,
1.211 + 0x7f, 0xff, 0xff, 0xff,
1.212 + 0x80, 0x00, 0x00, 0x00,
1.213 + 0xff, 0xff, 0xff, 0xff,
1.214 + 0xb6, 0xb1, 0xff, 0xef,
1.215 + 0x19, 0x6a, 0xca, 0x46 };
1.216 + ByteBuffer buffer(data, sizeof(data));
1.217 + ByteCursor cursor(&buffer);
1.218 + cursor.set_big_endian(true);
1.219 + int64_t a, b, c, d, e, f, g;
1.220 + ASSERT_TRUE(cursor
1.221 + .Read(4, true, &a)
1.222 + .Read(4, true, &b)
1.223 + .Read(4, true, &c)
1.224 + .Read(4, true, &d)
1.225 + .Read(4, true, &e)
1.226 + .Read(4, true, &f));
1.227 + EXPECT_EQ(0, a);
1.228 + EXPECT_EQ(0x7fffffff, b);
1.229 + EXPECT_EQ(-0x80000000LL, c);
1.230 + EXPECT_EQ(-1, d);
1.231 + EXPECT_EQ((int32_t) 0xb6b1ffef, e);
1.232 + EXPECT_EQ(0x196aca46, f);
1.233 + EXPECT_TRUE(cursor.AtEnd());
1.234 + EXPECT_FALSE(cursor.Read(4, true, &g));
1.235 +}
1.236 +
1.237 +TEST(BigEndian, Signed8) {
1.238 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.239 + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.240 + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.241 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.242 + 0x93, 0x20, 0xd5, 0xe9, 0xd2, 0xd5, 0x87, 0x9c,
1.243 + 0x4e, 0x42, 0x49, 0xd2, 0x7f, 0x84, 0x14, 0xa4 };
1.244 + ByteBuffer buffer(data, sizeof(data));
1.245 + ByteCursor cursor(&buffer, true);
1.246 + int64_t a, b, c, d, e, f, g;
1.247 + ASSERT_TRUE(cursor
1.248 + .Read(8, true, &a)
1.249 + .Read(8, true, &b)
1.250 + .Read(8, true, &c)
1.251 + .Read(8, true, &d)
1.252 + .Read(8, true, &e)
1.253 + .Read(8, true, &f));
1.254 + EXPECT_EQ(0, a);
1.255 + EXPECT_EQ(0x7fffffffffffffffLL, b);
1.256 + EXPECT_EQ(-0x7fffffffffffffffLL - 1, c);
1.257 + EXPECT_EQ(-1, d);
1.258 + EXPECT_EQ((int64_t) 0x9320d5e9d2d5879cULL, e);
1.259 + EXPECT_EQ(0x4e4249d27f8414a4LL, f);
1.260 + EXPECT_TRUE(cursor.AtEnd());
1.261 + EXPECT_FALSE(cursor.Read(8, true, &g));
1.262 +}
1.263 +
1.264 +TEST(BigEndian, Unsigned1) {
1.265 + uint8_t data[] = { 0x00, 0x7f, 0x80, 0xff };
1.266 + ByteBuffer buffer(data, sizeof(data));
1.267 + ByteCursor cursor(&buffer);
1.268 + cursor.set_big_endian(true);
1.269 + int32_t a, b, c, d, e;
1.270 + ASSERT_TRUE(cursor
1.271 + .Read(1, false, &a)
1.272 + .Read(1, false, &b)
1.273 + .Read(1, false, &c)
1.274 + .Read(1, false, &d));
1.275 + EXPECT_EQ(0, a);
1.276 + EXPECT_EQ(0x7f, b);
1.277 + EXPECT_EQ(0x80, c);
1.278 + EXPECT_EQ(0xff, d);
1.279 + EXPECT_TRUE(cursor.AtEnd());
1.280 + EXPECT_FALSE(cursor.Read(1, false, &e));
1.281 +}
1.282 +
1.283 +TEST(BigEndian, Unsigned2) {
1.284 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x80, 0x7f, 0xff,
1.285 + 0x80, 0x00, 0x80, 0x80, 0xff, 0xff,
1.286 + 0x39, 0xf1, 0x8a, 0xbc, 0x5a, 0xec };
1.287 + ByteBuffer buffer(data, sizeof(data));
1.288 + ByteCursor cursor(&buffer, true);
1.289 + int64_t a, b, c, d, e, f, g, h, i, j;
1.290 + ASSERT_TRUE(cursor
1.291 + .Read(2, false, &a)
1.292 + .Read(2, false, &b)
1.293 + .Read(2, false, &c)
1.294 + .Read(2, false, &d)
1.295 + .Read(2, false, &e)
1.296 + .Read(2, false, &f)
1.297 + .Read(2, false, &g)
1.298 + .Read(2, false, &h)
1.299 + .Read(2, false, &i));
1.300 + EXPECT_EQ(0, a);
1.301 + EXPECT_EQ(0x80, b);
1.302 + EXPECT_EQ(0x7fff, c);
1.303 + EXPECT_EQ(0x8000, d);
1.304 + EXPECT_EQ(0x8080, e);
1.305 + EXPECT_EQ(0xffff, f);
1.306 + EXPECT_EQ(0x39f1, g);
1.307 + EXPECT_EQ(0x8abc, h);
1.308 + EXPECT_EQ(0x5aec, i);
1.309 + EXPECT_TRUE(cursor.AtEnd());
1.310 + EXPECT_FALSE(cursor.Read(2, false, &j));
1.311 +}
1.312 +
1.313 +TEST(BigEndian, Unsigned4) {
1.314 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00,
1.315 + 0x7f, 0xff, 0xff, 0xff,
1.316 + 0x80, 0x00, 0x00, 0x00,
1.317 + 0xff, 0xff, 0xff, 0xff,
1.318 + 0xb6, 0xb1, 0xff, 0xef,
1.319 + 0x19, 0x6a, 0xca, 0x46 };
1.320 + ByteBuffer buffer(data, sizeof(data));
1.321 + ByteCursor cursor(&buffer);
1.322 + cursor.set_big_endian(true);
1.323 + int64_t a, b, c, d, e, f, g;
1.324 + ASSERT_TRUE(cursor
1.325 + .Read(4, false, &a)
1.326 + .Read(4, false, &b)
1.327 + .Read(4, false, &c)
1.328 + .Read(4, false, &d)
1.329 + .Read(4, false, &e)
1.330 + .Read(4, false, &f));
1.331 + EXPECT_EQ(0, a);
1.332 + EXPECT_EQ(0x7fffffff, b);
1.333 + EXPECT_EQ(0x80000000, c);
1.334 + EXPECT_EQ(0xffffffff, d);
1.335 + EXPECT_EQ(0xb6b1ffef, e);
1.336 + EXPECT_EQ(0x196aca46, f);
1.337 + EXPECT_TRUE(cursor.AtEnd());
1.338 + EXPECT_FALSE(cursor.Read(4, false, &g));
1.339 +}
1.340 +
1.341 +TEST(BigEndian, Unsigned8) {
1.342 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.343 + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.344 + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.345 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.346 + 0x93, 0x20, 0xd5, 0xe9, 0xd2, 0xd5, 0x87, 0x9c,
1.347 + 0x4e, 0x42, 0x49, 0xd2, 0x7f, 0x84, 0x14, 0xa4 };
1.348 + ByteBuffer buffer(data, sizeof(data));
1.349 + ByteCursor cursor(&buffer, true);
1.350 + uint64_t a, b, c, d, e, f, g;
1.351 + ASSERT_TRUE(cursor
1.352 + .Read(8, false, &a)
1.353 + .Read(8, false, &b)
1.354 + .Read(8, false, &c)
1.355 + .Read(8, false, &d)
1.356 + .Read(8, false, &e)
1.357 + .Read(8, false, &f));
1.358 + EXPECT_EQ(0U, a);
1.359 + EXPECT_EQ(0x7fffffffffffffffULL, b);
1.360 + EXPECT_EQ(0x8000000000000000ULL, c);
1.361 + EXPECT_EQ(0xffffffffffffffffULL, d);
1.362 + EXPECT_EQ(0x9320d5e9d2d5879cULL, e);
1.363 + EXPECT_EQ(0x4e4249d27f8414a4ULL, f);
1.364 + EXPECT_TRUE(cursor.AtEnd());
1.365 + EXPECT_FALSE(cursor.Read(8, false, &g));
1.366 +}
1.367 +
1.368 +TEST(LittleEndian, Signed1) {
1.369 + uint8_t data[] = { 0x00, 0x7f, 0x80, 0xff };
1.370 + ByteBuffer buffer(data, sizeof(data));
1.371 + ByteCursor cursor(&buffer);
1.372 + int32_t a, b, c, d, e;
1.373 + ASSERT_TRUE(cursor
1.374 + .Read(1, true, &a)
1.375 + .Read(1, true, &b)
1.376 + .Read(1, true, &c)
1.377 + .Read(1, true, &d));
1.378 + EXPECT_EQ(0, a);
1.379 + EXPECT_EQ(0x7f, b);
1.380 + EXPECT_EQ(-0x80, c);
1.381 + EXPECT_EQ(-1, d);
1.382 + EXPECT_TRUE(cursor.AtEnd());
1.383 + EXPECT_FALSE(cursor.Read(1, true, &e));
1.384 +}
1.385 +
1.386 +TEST(LittleEndian, Signed2) {
1.387 + uint8_t data[] = { 0x00, 0x00, 0x80, 0x00, 0xff, 0x7f,
1.388 + 0x00, 0x80, 0x80, 0x80, 0xff, 0xff,
1.389 + 0xf1, 0x39, 0xbc, 0x8a, 0xec, 0x5a };
1.390 + ByteBuffer buffer(data, sizeof(data));
1.391 + ByteCursor cursor(&buffer, false);
1.392 + int32_t a, b, c, d, e, f, g, h, i, j;
1.393 + ASSERT_TRUE(cursor
1.394 + .Read(2, true, &a)
1.395 + .Read(2, true, &b)
1.396 + .Read(2, true, &c)
1.397 + .Read(2, true, &d)
1.398 + .Read(2, true, &e)
1.399 + .Read(2, true, &f)
1.400 + .Read(2, true, &g)
1.401 + .Read(2, true, &h)
1.402 + .Read(2, true, &i));
1.403 + EXPECT_EQ(0, a);
1.404 + EXPECT_EQ(0x80, b);
1.405 + EXPECT_EQ(0x7fff, c);
1.406 + EXPECT_EQ(-0x8000, d);
1.407 + EXPECT_EQ(-0x7f80, e);
1.408 + EXPECT_EQ(-1, f);
1.409 + EXPECT_EQ(0x39f1, g);
1.410 + EXPECT_EQ(-0x7544, h);
1.411 + EXPECT_EQ(0x5aec, i);
1.412 + EXPECT_TRUE(cursor.AtEnd());
1.413 + EXPECT_FALSE(cursor.Read(2, true, &j));
1.414 +}
1.415 +
1.416 +TEST(LittleEndian, Signed4) {
1.417 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00,
1.418 + 0xff, 0xff, 0xff, 0x7f,
1.419 + 0x00, 0x00, 0x00, 0x80,
1.420 + 0xff, 0xff, 0xff, 0xff,
1.421 + 0xef, 0xff, 0xb1, 0xb6,
1.422 + 0x46, 0xca, 0x6a, 0x19 };
1.423 + ByteBuffer buffer(data, sizeof(data));
1.424 + ByteCursor cursor(&buffer);
1.425 + int64_t a, b, c, d, e, f, g;
1.426 + ASSERT_TRUE(cursor
1.427 + .Read(4, true, &a)
1.428 + .Read(4, true, &b)
1.429 + .Read(4, true, &c)
1.430 + .Read(4, true, &d)
1.431 + .Read(4, true, &e)
1.432 + .Read(4, true, &f));
1.433 + EXPECT_EQ(0, a);
1.434 + EXPECT_EQ(0x7fffffff, b);
1.435 + EXPECT_EQ(-0x80000000LL, c);
1.436 + EXPECT_EQ(-1, d);
1.437 + EXPECT_EQ((int32_t) 0xb6b1ffef, e);
1.438 + EXPECT_EQ(0x196aca46, f);
1.439 + EXPECT_TRUE(cursor.AtEnd());
1.440 + EXPECT_FALSE(cursor.Read(4, true, &g));
1.441 +}
1.442 +
1.443 +TEST(LittleEndian, Signed8) {
1.444 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.445 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
1.446 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1.447 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.448 + 0x9c, 0x87, 0xd5, 0xd2, 0xe9, 0xd5, 0x20, 0x93,
1.449 + 0xa4, 0x14, 0x84, 0x7f, 0xd2, 0x49, 0x42, 0x4e };
1.450 + ByteBuffer buffer(data, sizeof(data));
1.451 + ByteCursor cursor(&buffer, false);
1.452 + int64_t a, b, c, d, e, f, g;
1.453 + ASSERT_TRUE(cursor
1.454 + .Read(8, true, &a)
1.455 + .Read(8, true, &b)
1.456 + .Read(8, true, &c)
1.457 + .Read(8, true, &d)
1.458 + .Read(8, true, &e)
1.459 + .Read(8, true, &f));
1.460 + EXPECT_EQ(0, a);
1.461 + EXPECT_EQ(0x7fffffffffffffffLL, b);
1.462 + EXPECT_EQ(-0x7fffffffffffffffLL - 1, c);
1.463 + EXPECT_EQ(-1, d);
1.464 + EXPECT_EQ((int64_t) 0x9320d5e9d2d5879cULL, e);
1.465 + EXPECT_EQ(0x4e4249d27f8414a4LL, f);
1.466 + EXPECT_TRUE(cursor.AtEnd());
1.467 + EXPECT_FALSE(cursor.Read(8, true, &g));
1.468 +}
1.469 +
1.470 +TEST(LittleEndian, Unsigned1) {
1.471 + uint8_t data[] = { 0x00, 0x7f, 0x80, 0xff };
1.472 + ByteBuffer buffer(data, sizeof(data));
1.473 + ByteCursor cursor(&buffer);
1.474 + int32_t a, b, c, d, e;
1.475 + ASSERT_TRUE(cursor
1.476 + .Read(1, false, &a)
1.477 + .Read(1, false, &b)
1.478 + .Read(1, false, &c)
1.479 + .Read(1, false, &d));
1.480 + EXPECT_EQ(0, a);
1.481 + EXPECT_EQ(0x7f, b);
1.482 + EXPECT_EQ(0x80, c);
1.483 + EXPECT_EQ(0xff, d);
1.484 + EXPECT_TRUE(cursor.AtEnd());
1.485 + EXPECT_FALSE(cursor.Read(1, false, &e));
1.486 +}
1.487 +
1.488 +TEST(LittleEndian, Unsigned2) {
1.489 + uint8_t data[] = { 0x00, 0x00, 0x80, 0x00, 0xff, 0x7f,
1.490 + 0x00, 0x80, 0x80, 0x80, 0xff, 0xff,
1.491 + 0xf1, 0x39, 0xbc, 0x8a, 0xec, 0x5a };
1.492 + ByteBuffer buffer(data, sizeof(data));
1.493 + ByteCursor cursor(&buffer);
1.494 + int32_t a, b, c, d, e, f, g, h, i, j;
1.495 + ASSERT_TRUE(cursor
1.496 + .Read(2, false, &a)
1.497 + .Read(2, false, &b)
1.498 + .Read(2, false, &c)
1.499 + .Read(2, false, &d)
1.500 + .Read(2, false, &e)
1.501 + .Read(2, false, &f)
1.502 + .Read(2, false, &g)
1.503 + .Read(2, false, &h)
1.504 + .Read(2, false, &i));
1.505 + EXPECT_EQ(0, a);
1.506 + EXPECT_EQ(0x80, b);
1.507 + EXPECT_EQ(0x7fff, c);
1.508 + EXPECT_EQ(0x8000, d);
1.509 + EXPECT_EQ(0x8080, e);
1.510 + EXPECT_EQ(0xffff, f);
1.511 + EXPECT_EQ(0x39f1, g);
1.512 + EXPECT_EQ(0x8abc, h);
1.513 + EXPECT_EQ(0x5aec, i);
1.514 + EXPECT_TRUE(cursor.AtEnd());
1.515 + EXPECT_FALSE(cursor.Read(2, false, &j));
1.516 +}
1.517 +
1.518 +TEST(LittleEndian, Unsigned4) {
1.519 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00,
1.520 + 0xff, 0xff, 0xff, 0x7f,
1.521 + 0x00, 0x00, 0x00, 0x80,
1.522 + 0xff, 0xff, 0xff, 0xff,
1.523 + 0xef, 0xff, 0xb1, 0xb6,
1.524 + 0x46, 0xca, 0x6a, 0x19 };
1.525 + ByteBuffer buffer(data, sizeof(data));
1.526 + ByteCursor cursor(&buffer);
1.527 + int64_t a, b, c, d, e, f, g;
1.528 + ASSERT_TRUE(cursor
1.529 + .Read(4, false, &a)
1.530 + .Read(4, false, &b)
1.531 + .Read(4, false, &c)
1.532 + .Read(4, false, &d)
1.533 + .Read(4, false, &e)
1.534 + .Read(4, false, &f));
1.535 + EXPECT_EQ(0, a);
1.536 + EXPECT_EQ(0x7fffffff, b);
1.537 + EXPECT_EQ(0x80000000, c);
1.538 + EXPECT_EQ(0xffffffff, d);
1.539 + EXPECT_EQ(0xb6b1ffef, e);
1.540 + EXPECT_EQ(0x196aca46, f);
1.541 + EXPECT_TRUE(cursor.AtEnd());
1.542 + EXPECT_FALSE(cursor.Read(4, false, &g));
1.543 +}
1.544 +
1.545 +TEST(LittleEndian, Unsigned8) {
1.546 + uint8_t data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1.547 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
1.548 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1.549 + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1.550 + 0x9c, 0x87, 0xd5, 0xd2, 0xe9, 0xd5, 0x20, 0x93,
1.551 + 0xa4, 0x14, 0x84, 0x7f, 0xd2, 0x49, 0x42, 0x4e };
1.552 + ByteBuffer buffer(data, sizeof(data));
1.553 + ByteCursor cursor(&buffer);
1.554 + uint64_t a, b, c, d, e, f, g;
1.555 + ASSERT_TRUE(cursor
1.556 + .Read(8, false, &a)
1.557 + .Read(8, false, &b)
1.558 + .Read(8, false, &c)
1.559 + .Read(8, false, &d)
1.560 + .Read(8, false, &e)
1.561 + .Read(8, false, &f));
1.562 + EXPECT_EQ(0U, a);
1.563 + EXPECT_EQ(0x7fffffffffffffffULL, b);
1.564 + EXPECT_EQ(0x8000000000000000ULL, c);
1.565 + EXPECT_EQ(0xffffffffffffffffULL, d);
1.566 + EXPECT_EQ(0x9320d5e9d2d5879cULL, e);
1.567 + EXPECT_EQ(0x4e4249d27f8414a4ULL, f);
1.568 + EXPECT_TRUE(cursor.AtEnd());
1.569 + EXPECT_FALSE(cursor.Read(8, false, &g));
1.570 +}
1.571 +
1.572 +TEST(Extractor, Signed1) {
1.573 + uint8_t data[] = { 0xfd };
1.574 + ByteBuffer buffer(data, sizeof(data));
1.575 + ByteCursor cursor(&buffer);
1.576 + int8_t a;
1.577 + EXPECT_TRUE(cursor >> a);
1.578 + EXPECT_EQ(-3, a);
1.579 + EXPECT_FALSE(cursor >> a);
1.580 +}
1.581 +
1.582 +TEST(Extractor, Signed2) {
1.583 + uint8_t data[] = { 0x13, 0xcd };
1.584 + ByteBuffer buffer(data, sizeof(data));
1.585 + ByteCursor cursor(&buffer);
1.586 + int16_t a;
1.587 + EXPECT_TRUE(cursor >> a);
1.588 + EXPECT_EQ(-13037, a);
1.589 + EXPECT_FALSE(cursor >> a);
1.590 +}
1.591 +
1.592 +TEST(Extractor, Signed4) {
1.593 + uint8_t data[] = { 0xd2, 0xe4, 0x53, 0xe9 };
1.594 + ByteBuffer buffer(data, sizeof(data));
1.595 + ByteCursor cursor(&buffer);
1.596 + int32_t a;
1.597 + // For some reason, G++ 4.4.1 complains:
1.598 + // warning: array subscript is above array bounds
1.599 + // in ByteCursor::Read(size_t, bool, T *) as it inlines this call, but
1.600 + // I'm not able to see how such a reference would occur.
1.601 + EXPECT_TRUE(cursor >> a);
1.602 + EXPECT_EQ(-380377902, a);
1.603 + EXPECT_FALSE(cursor >> a);
1.604 +}
1.605 +
1.606 +TEST(Extractor, Unsigned1) {
1.607 + uint8_t data[] = { 0xfd };
1.608 + ByteBuffer buffer(data, sizeof(data));
1.609 + ByteCursor cursor(&buffer);
1.610 + uint8_t a;
1.611 + EXPECT_TRUE(cursor >> a);
1.612 + EXPECT_EQ(0xfd, a);
1.613 + EXPECT_FALSE(cursor >> a);
1.614 +}
1.615 +
1.616 +TEST(Extractor, Unsigned2) {
1.617 + uint8_t data[] = { 0x13, 0xcd };
1.618 + ByteBuffer buffer(data, sizeof(data));
1.619 + ByteCursor cursor(&buffer);
1.620 + uint16_t a;
1.621 + EXPECT_TRUE(cursor >> a);
1.622 + EXPECT_EQ(0xcd13, a);
1.623 + EXPECT_FALSE(cursor >> a);
1.624 +}
1.625 +
1.626 +TEST(Extractor, Unsigned4) {
1.627 + uint8_t data[] = { 0xd2, 0xe4, 0x53, 0xe9 };
1.628 + ByteBuffer buffer(data, sizeof(data));
1.629 + ByteCursor cursor(&buffer);
1.630 + uint32_t a;
1.631 + // For some reason, G++ 4.4.1 complains:
1.632 + // warning: array subscript is above array bounds
1.633 + // in ByteCursor::Read(size_t, bool, T *) as it inlines this call, but
1.634 + // I'm not able to see how such a reference would occur.
1.635 + EXPECT_TRUE(cursor >> a);
1.636 + EXPECT_EQ(0xe953e4d2, a);
1.637 + EXPECT_FALSE(cursor >> a);
1.638 + EXPECT_FALSE(cursor >> a);
1.639 +}
1.640 +
1.641 +TEST(Extractor, Mixed) {
1.642 + uint8_t data[] = { 0x42,
1.643 + 0x25, 0x0b,
1.644 + 0x3d, 0x25, 0xed, 0x2a,
1.645 + 0xec, 0x16, 0x9e, 0x14, 0x61, 0x5b, 0x2c, 0xcf,
1.646 + 0xd8,
1.647 + 0x22, 0xa5,
1.648 + 0x3a, 0x02, 0x6a, 0xd7,
1.649 + 0x93, 0x2a, 0x2d, 0x8d, 0xb4, 0x95, 0xe0, 0xc6 };
1.650 + ByteBuffer buffer(data, sizeof(data));
1.651 + ByteCursor cursor(&buffer);
1.652 + cursor.set_big_endian(true);
1.653 +
1.654 + uint8_t a;
1.655 + uint16_t b;
1.656 + uint32_t c;
1.657 + uint64_t d;
1.658 + int8_t e;
1.659 + int16_t f;
1.660 + int32_t g;
1.661 + int64_t h;
1.662 + int z;
1.663 + EXPECT_FALSE(cursor.AtEnd());
1.664 + EXPECT_TRUE(cursor >> a >> b >> c >> d >> e >> f >> g >> h);
1.665 + EXPECT_EQ(0x42U, a);
1.666 + EXPECT_EQ(0x250bU, b);
1.667 + EXPECT_EQ(0x3d25ed2aU, c);
1.668 + EXPECT_EQ(0xec169e14615b2ccfULL, d);
1.669 + EXPECT_EQ(-40, e);
1.670 + EXPECT_EQ(0x22a5, f);
1.671 + EXPECT_EQ(0x3a026ad7, g);
1.672 + EXPECT_EQ(-7842405714468937530LL, h);
1.673 +
1.674 + EXPECT_TRUE(cursor.AtEnd());
1.675 + EXPECT_FALSE(cursor >> z);
1.676 +}
1.677 +
1.678 +TEST(Strings, Zero) {
1.679 + uint8_t data[] = { 0xa6 };
1.680 + ByteBuffer buffer(data, 0);
1.681 + ByteCursor cursor(&buffer);
1.682 +
1.683 + uint8_t received[1];
1.684 + received[0] = 0xc2;
1.685 + EXPECT_TRUE(cursor.Read(received, 0));
1.686 + EXPECT_EQ(0xc2U, received[0]);
1.687 +}
1.688 +
1.689 +TEST(Strings, Some) {
1.690 + uint8_t data[] = { 0x5d, 0x31, 0x09, 0xa6, 0x2e, 0x2c, 0x83, 0xbb };
1.691 + ByteBuffer buffer(data, sizeof(data));
1.692 + ByteCursor cursor(&buffer);
1.693 +
1.694 + uint8_t received[7] = { 0xa7, 0xf7, 0x43, 0x0c, 0x27, 0xea, 0xed };
1.695 + EXPECT_TRUE(cursor.Skip(2).Read(received, 5));
1.696 + uint8_t expected[7] = { 0x09, 0xa6, 0x2e, 0x2c, 0x83, 0xea, 0xed };
1.697 + EXPECT_TRUE(memcmp(received, expected, 7) == 0);
1.698 +}
1.699 +
1.700 +TEST(Strings, TooMuch) {
1.701 + uint8_t data[] = { 0x5d, 0x31, 0x09, 0xa6, 0x2e, 0x2c, 0x83, 0xbb };
1.702 + ByteBuffer buffer(data, sizeof(data));
1.703 + ByteCursor cursor(&buffer);
1.704 +
1.705 + uint8_t received1[3];
1.706 + uint8_t received2[3];
1.707 + uint8_t received3[3];
1.708 + EXPECT_FALSE(cursor
1.709 + .Read(received1, 3)
1.710 + .Read(received2, 3)
1.711 + .Read(received3, 3));
1.712 + uint8_t expected1[3] = { 0x5d, 0x31, 0x09 };
1.713 + uint8_t expected2[3] = { 0xa6, 0x2e, 0x2c };
1.714 +
1.715 + EXPECT_TRUE(memcmp(received1, expected1, 3) == 0);
1.716 + EXPECT_TRUE(memcmp(received2, expected2, 3) == 0);
1.717 +}
1.718 +
1.719 +TEST(Strings, PointTo) {
1.720 + uint8_t data[] = { 0x83, 0x80, 0xb4, 0x38, 0x00, 0x2c, 0x0a, 0x27 };
1.721 + ByteBuffer buffer(data, sizeof(data));
1.722 + ByteCursor cursor(&buffer);
1.723 +
1.724 + const uint8_t *received1;
1.725 + const uint8_t *received2;
1.726 + const uint8_t *received3;
1.727 + const uint8_t *received4;
1.728 + EXPECT_FALSE(cursor
1.729 + .PointTo(&received1, 3)
1.730 + .PointTo(&received2, 3)
1.731 + .PointTo(&received3)
1.732 + .PointTo(&received4, 3));
1.733 + EXPECT_EQ(data + 0, received1);
1.734 + EXPECT_EQ(data + 3, received2);
1.735 + EXPECT_EQ(data + 6, received3);
1.736 + EXPECT_EQ(NULL, received4);
1.737 +}
1.738 +
1.739 +TEST(Strings, CString) {
1.740 + uint8_t data[] = "abc\0\0foo";
1.741 + ByteBuffer buffer(data, sizeof(data) - 1); // don't include terminating '\0'
1.742 + ByteCursor cursor(&buffer);
1.743 +
1.744 + string a, b, c;
1.745 + EXPECT_TRUE(cursor.CString(&a).CString(&b));
1.746 + EXPECT_EQ("abc", a);
1.747 + EXPECT_EQ("", b);
1.748 + EXPECT_FALSE(cursor.CString(&c));
1.749 + EXPECT_EQ("", c);
1.750 + EXPECT_TRUE(cursor.AtEnd());
1.751 +}
1.752 +
1.753 +TEST(Strings, CStringLimit) {
1.754 + uint8_t data[] = "abcdef\0\0foobar";
1.755 + ByteBuffer buffer(data, sizeof(data) - 1); // don't include terminating '\0'
1.756 + ByteCursor cursor(&buffer);
1.757 +
1.758 + string a, b, c, d, e;
1.759 +
1.760 + EXPECT_TRUE(cursor.CString(&a, 3));
1.761 + EXPECT_EQ("abc", a);
1.762 +
1.763 + EXPECT_TRUE(cursor.CString(&b, 0));
1.764 + EXPECT_EQ("", b);
1.765 +
1.766 + EXPECT_TRUE(cursor.CString(&c, 6));
1.767 + EXPECT_EQ("def", c);
1.768 +
1.769 + EXPECT_TRUE(cursor.CString(&d, 4));
1.770 + EXPECT_EQ("ooba", d);
1.771 +
1.772 + EXPECT_FALSE(cursor.CString(&e, 4));
1.773 + EXPECT_EQ("", e);
1.774 +
1.775 + EXPECT_TRUE(cursor.AtEnd());
1.776 +}
1.777 +
1.778 +// uint8_t data[] = { 0xa6, 0x54, 0xdf, 0x67, 0x51, 0x43, 0xac, 0xf1 };
1.779 +// ByteBuffer buffer(data, sizeof(data));
