cppcache/test/ByteArrayTest.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ByteArrayFixture.hpp"

using apache::geode::client::ByteArray;

TEST(ByteArrayTest, TestNoArgConstructor) {
  const ByteArray ba;
  EXPECT_EQ(0U, ba.size()) << "Zero size for no-arg constructor";
  EXPECT_EQ(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba))
      << "Null pointer for no-arg constructor";
}

TEST(ByteArrayTest, TestTwoArgConstructor) {
  const uint8_t bytes[] = {0xDE, 0xAD, 0xBE, 0xEF};
  const ByteArray ba(bytes, 4);
  EXPECT_EQ(4U, ba.size()) << "Correct size for two-arg constructor";
  EXPECT_NE(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba))
      << "Non-null pointer for two-arg constructor";
  EXPECT_EQ(0xDE, ba[0]) << "Correct zeroth byte for two-arg constructor";
  EXPECT_EQ(0xAD, ba[1]) << "Correct first byte for two-arg constructor";
  EXPECT_EQ(0xBE, ba[2]) << "Correct second byte for two-arg constructor";
  EXPECT_EQ(0xEF, ba[3]) << "Correct third byte for two-arg constructor";
}

TEST(ByteArrayTest, TestCopyConstructor) {
  const uint8_t bytes[] = {0xDE, 0xAD, 0xBE, 0xEF};
  const ByteArray ba1(bytes, 4U);
  const ByteArray ba2(ba1);
  EXPECT_EQ(4U, ba2.size()) << "Correct size for copy constructor";
  EXPECT_NE(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba2))
      << "Non-null pointer for copy constructor";
  EXPECT_EQ(0xDE, ba2[0]) << "Correct zeroth byte for copy constructor";
  EXPECT_EQ(0xAD, ba2[1]) << "Correct first byte for copy constructor";
  EXPECT_EQ(0xBE, ba2[2]) << "Correct second byte for copy constructor";
  EXPECT_EQ(0xEF, ba2[3]) << "Correct third byte for copy constructor";
}

TEST(ByteArrayTest, TestAssignmentOperator) {
  ByteArray ba2;
  const uint8_t bytes[] = {0xDE, 0xAD, 0xBE, 0xEF};
  const ByteArray ba1(bytes, 4U);
  ba2 = ba1;
  EXPECT_EQ(4U, ba2.size()) << "Correct size for assignment operator";
  EXPECT_NE(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba2))
      << "Non-null pointer for assignment operator";
  EXPECT_EQ(0xDE, ba2[0]) << "Correct zeroth byte for assignment operator";
  EXPECT_EQ(0xAD, ba2[1]) << "Correct first byte for assignment operator";
  EXPECT_EQ(0xBE, ba2[2]) << "Correct second byte for assignment operator";
  EXPECT_EQ(0xEF, ba2[3]) << "Correct third byte for assignment operator";
}

TEST(ByteArrayTest, TestFromStringForEmpty) {
  const std::string empty;
  const ByteArray ba(ByteArray::fromString(empty));
  EXPECT_EQ(0U, ba.size()) << "Zero size for empty string";
  EXPECT_EQ(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba))
      << "Null pointer for empty string";
}

TEST(ByteArrayTest, TestFromStringForOneCharacter) {
  const std::string one("A");
  const ByteArray ba(ByteArray::fromString(one));
  EXPECT_EQ(1U, ba.size()) << "Correct size for one character";
  EXPECT_NE(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba))
      << "Non-null pointer for one character";
  EXPECT_EQ(0xA0, ba[0]) << "Correct zeroth byte for one character";
}

TEST(ByteArrayTest, TestFromStringForEightCharacters) {
  const std::string eight("BABEFACE");
  const ByteArray ba(ByteArray::fromString(eight));
  EXPECT_EQ(4U, ba.size()) << "Correct size for eight characters";
  EXPECT_NE(static_cast<const uint8_t *>(nullptr),
            static_cast<const uint8_t *>(ba))
      << "Non-null pointer for eight characters";
  EXPECT_EQ(0xBA, ba[0]) << "Correct zeroth byte for eight characters";
  EXPECT_EQ(0xBE, ba[1]) << "Correct first byte for eight characters";
  EXPECT_EQ(0xFA, ba[2]) << "Correct second byte for eight characters";
  EXPECT_EQ(0xCE, ba[3]) << "Correct third byte for eight characters";
}

TEST(ByteArrayTest, TestToStringForEmpty) {
  const ByteArray ba;
  EXPECT_EQ(std::string(), ByteArray::toString(ba))
      << "Empty string for empty byte array";
}

TEST(ByteArrayTest, TestToStringForOneByte) {
  const uint8_t bytes[] = {0x25};
  const ByteArray ba(bytes, 1U);
  EXPECT_EQ(std::string("25"), ByteArray::toString(ba))
      << "Correct string for one byte";
}

TEST(ByteArrayTest, TestToStringForFourBytes) {
  const uint8_t bytes[] = {0xBA, 0xBE, 0xFA, 0xCE};
  const ByteArray ba(bytes, 4U);
  EXPECT_EQ(std::string("BABEFACE"), ByteArray::toString(ba))
      << "Correct string for four bytes";
}