cpp-string-utils/test/cast_test.cxx

//
//  cast_test.cxx
//  string_utils-test
//
//  Created by Sam Jaffe on 2/14/21.
//  Copyright © 2021 Sam Jaffe. All rights reserved.
//

#include "string_utils/cast.h"

#include "xcode_gtest_helper.h"

using testing::FieldsAre;
using testing::Pair;
using namespace string_utils;

TEST(CastIntegerTest, CastsWithBase10) {
  auto [value, success] = cast<int>("10");
  EXPECT_TRUE(success);
  EXPECT_THAT(value, 10);
}

TEST(CastIntegerTest, DoesNotCastBase8) {
  auto [value, success] = cast<int>("010");
  EXPECT_TRUE(success);
  EXPECT_THAT(value, 10);
}

TEST(CastIntegerTest, DoesNotCastHex) {
  auto [value, success] = cast<int>("0x10");
  EXPECT_FALSE(success);
  EXPECT_THAT(value, 0);
}

TEST(CastIntegerTest, FailsOnBadData) {
  auto [value, success] = cast<int>("x");
  EXPECT_FALSE(success);
  EXPECT_THAT(value, 0);
}

TEST(CastIntegerTest, FailsOnBadSuffix) {
  auto [value, success] = cast<int>("10x");
  EXPECT_FALSE(success);
  EXPECT_THAT(value, 10);
}

TEST(CastIntegerTest, FailsOnOutOfBounds) {
  auto [_, success] = cast<int>("2147483648");
  EXPECT_FALSE(success);
}

TEST(CastBooleanTest, CastsVariousTrueValues) {
  EXPECT_THAT(cast<bool>("true"), Pair(true, true));
  EXPECT_THAT(cast<bool>("TRUE"), Pair(true, true));
  EXPECT_THAT(cast<bool>("YES"), Pair(true, true));
  EXPECT_THAT(cast<bool>("1"), Pair(true, true));
}

TEST(CastBooleanTest, CastsVariousFalseValues) {
  EXPECT_THAT(cast<bool>("false"), Pair(false, true));
  EXPECT_THAT(cast<bool>("FALSE"), Pair(false, true));
  EXPECT_THAT(cast<bool>("NO"), Pair(false, true));
  EXPECT_THAT(cast<bool>("0"), Pair(false, true));
}

TEST(CastBooleanTest, DoesNotCastAllIntegers) {
  auto [_, success] = cast<bool>("2");
  EXPECT_FALSE(success);
}

MATCHER_P(HoldsAlternative, typearg,
          std::string("holds a value of type ") + typeid(typearg).name()) {
  using T = std::remove_const_t<std::decay_t<decltype(typearg)>>;
  return std::holds_alternative<T>(arg);
}

template <typename T> auto HoldsAlternative() { return HoldsAlternative(T()); }

TEST(CastVariantTest, StringVariantWillAlwaysMatchWhenEncountered) {
  auto [value, success] = cast<std::variant<std::string, int>>("2");
  EXPECT_THAT(value, HoldsAlternative<std::string>());
}

TEST(CastVariantTest, EvaluatesTypesLeftToRight) {
  auto [value, success] = cast<std::variant<int, std::string>>("2");
  EXPECT_THAT(value, HoldsAlternative<int>());
}

using pair_t = std::pair<std::string, std::string>;
using tuple_t = std::tuple<int, int, std::string>;

TEST(CastKeyValTest, FailsOnTooFewTokens) {
  auto [value, success] = cast<pair_t>(std::vector{"key"});
  EXPECT_FALSE(success);
}

TEST(CastKeyValTest, ParsesTokens) {
  auto [value, success] = cast<pair_t>(std::vector{"key","value"});
  EXPECT_TRUE(success);
  EXPECT_THAT(value, Pair("key", "value"));
}

TEST(CastKeyValTest, FailsOnTooManyTokens) {
  auto [value, success] = cast<pair_t>(std::vector{"key","value","mapping"});
  EXPECT_FALSE(success);
}

TEST(CastTupleTest, FailsOnTooFewTokens) {
  auto [value, success] = cast<tuple_t>(std::vector{"0","A"});
  EXPECT_FALSE(success);
}

TEST(CastTupleTest, FailsOnTooManyTokens) {
  auto [value, success] = cast<tuple_t>(std::vector{"0","1","A","B"});
  EXPECT_FALSE(success);
}

TEST(CastTupleTest, ParsesIfAllGood) {
  auto [value, success] = cast<tuple_t>(std::vector{"0","1","A"});
  EXPECT_TRUE(success);
  EXPECT_THAT(value, FieldsAre(0, 1, "A"));
}

TEST(CastTupleTest, FailsOnAnyParseError) {
  auto [value, success] = cast<tuple_t>(std::vector{"0","Q","A"});
  EXPECT_FALSE(success);
}