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 "string_utils/split.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>());
}

TEST(CastKeyValTest, FailsOnTooFewTokens) {
  auto [value, success] = to_keyval("key");
  EXPECT_FALSE(success);
}

TEST(CastKeyValTest, SplitsOnFirstToken) {
  auto [value, success] = to_keyval("key=value");
  EXPECT_TRUE(success);
  EXPECT_THAT(value, Pair("key", "value"));
}

TEST(CastKeyValTest, CanProvideAlternateSplitToken) {
  auto [value, success] = to_keyval("key=value", 'v');
  EXPECT_TRUE(success);
  EXPECT_THAT(value, Pair("key=", "alue"));
}

TEST(CastKeyValTest, ExtraTokensAreStoredInValue) {
  auto [value, success] = to_keyval("key=value=mapping");
  EXPECT_TRUE(success);
  EXPECT_THAT(value, Pair("key", "value=mapping"));
}

TEST(CastTupleTest, FailsOnTooFewTokens) {
  auto [value, success] = to_tuple<int, int, std::string>("0,A");
  EXPECT_FALSE(success);
}

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

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

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

TEST(CastTupleTest, CanQuoteArguments) {
  auto [value, success] = to_tuple<int, int, std::string>("0,1,\"A,B\"");
  EXPECT_TRUE(success);
  EXPECT_THAT(value, FieldsAre(0, 1, "A,B"));
}