carbon-lang/common/string_helpers_test.cpp

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include "common/string_helpers.h"

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <optional>
#include <string>

#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"

using ::testing::Eq;
using ::testing::Optional;
using ::testing::StrEq;

namespace Carbon {
namespace {

TEST(UnescapeStringLiteral, Valid) {
  EXPECT_THAT(UnescapeStringLiteral("test"), Optional(Eq("test")));
  EXPECT_THAT(UnescapeStringLiteral("okay whitespace"),
              Optional(Eq("okay whitespace")));
  EXPECT_THAT(UnescapeStringLiteral("test\n"), Optional(Eq("test\n")));
  EXPECT_THAT(UnescapeStringLiteral("test\\n"), Optional(Eq("test\n")));
  EXPECT_THAT(UnescapeStringLiteral("abc\\ndef"), Optional(Eq("abc\ndef")));
  EXPECT_THAT(UnescapeStringLiteral("test\\\\n"), Optional(Eq("test\\n")));
  EXPECT_THAT(UnescapeStringLiteral("\\xAA"), Optional(Eq("\xAA")));
  EXPECT_THAT(UnescapeStringLiteral("\\x12"), Optional(Eq("\x12")));
  EXPECT_THAT(UnescapeStringLiteral("test", 1), Optional(Eq("test")));
  EXPECT_THAT(UnescapeStringLiteral("test\\#n", 1), Optional(Eq("test\n")));
  EXPECT_THAT(UnescapeStringLiteral(
                  "r\\u{000000E9}al \\u{2764}\\u{FE0F}\\u{1F50A}!\\u{10FFFF}"),
              Optional(Eq("réal ❤️🔊!􏿿")));
}

TEST(UnescapeStringLiteral, Invalid) {
  // Missing char after `\`.
  EXPECT_THAT(UnescapeStringLiteral("a\\"), Eq(std::nullopt));
  // Not a supported escape.
  EXPECT_THAT(UnescapeStringLiteral("\\e"), Eq(std::nullopt));
  // Needs 2 hex chars.
  EXPECT_THAT(UnescapeStringLiteral("\\x"), Eq(std::nullopt));
  // Needs 2 hex chars.
  EXPECT_THAT(UnescapeStringLiteral("\\xA"), Eq(std::nullopt));
  // Needs uppercase hex.
  EXPECT_THAT(UnescapeStringLiteral("\\xaa"), Eq(std::nullopt));
  // Reserved.
  EXPECT_THAT(UnescapeStringLiteral("\\00"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\#00", 1), Eq(std::nullopt));
}

TEST(UnescapeStringLiteral, InvalidUnicodes) {
  // Various incomplete Unicode specifiers
  EXPECT_THAT(UnescapeStringLiteral("\\u"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u1"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\uz"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u{"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u{z"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u{E9"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u{E9z"), Eq(std::nullopt));
  EXPECT_THAT(UnescapeStringLiteral("\\u{}"), Eq(std::nullopt));

  // invalid characters in unicode
  EXPECT_THAT(UnescapeStringLiteral("\\u{z}"), Eq(std::nullopt));

  // lowercase hexadecimal
  EXPECT_THAT(UnescapeStringLiteral("\\u{e9}"), Eq(std::nullopt));

  // Codepoint number too high
  EXPECT_THAT(UnescapeStringLiteral("\\u{110000}"), Eq(std::nullopt));

  // codepoint more than 8 hex digits
  EXPECT_THAT(UnescapeStringLiteral("\\u{FF000000E9}"), Eq(std::nullopt));
}

TEST(UnescapeStringLiteral, Nul) {
  std::optional<std::string> str = UnescapeStringLiteral("a\\0b");
  ASSERT_NE(str, std::nullopt);
  EXPECT_THAT(str->size(), Eq(3));
  EXPECT_THAT(strlen(str->c_str()), Eq(1));
  EXPECT_THAT((*str)[0], Eq('a'));
  EXPECT_THAT((*str)[1], Eq('\0'));
  EXPECT_THAT((*str)[2], Eq('b'));
}

TEST(ParseBlockStringLiteral, FailTooFewLines) {
  EXPECT_THAT(ParseBlockStringLiteral("").error().message(),
              Eq("Too few lines"));
}

TEST(ParseBlockStringLiteral, FailNoLeadingTripleQuotes) {
  EXPECT_THAT(ParseBlockStringLiteral("'a'\n").error().message(),
              Eq("Should start with triple quotes: 'a'"));
}

TEST(ParseBlockStringLiteral, FailInvalideFiletypeIndicator) {
  EXPECT_THAT(ParseBlockStringLiteral("'''carbon file\n").error().message(),
              Eq("Invalid characters in file type indicator: carbon file"));
}

TEST(ParseBlockStringLiteral, FailEndingTripleQuotes) {
  EXPECT_THAT(ParseBlockStringLiteral("'''\n").error().message(),
              Eq("Should end with triple quotes: "));
}

TEST(ParseBlockStringLiteral, FailWrongIndent) {
  constexpr char Input[] = R"('''
     A block string literal
    with wrong indent
     ''')";
  EXPECT_THAT(ParseBlockStringLiteral(Input).error().message(),
              Eq("Wrong indent for line:     with wrong indent, expected 5"));
}

TEST(ParseBlockStringLiteral, FailInvalidEscaping) {
  constexpr char Input[] = R"('''
     \q
     ''')";
  EXPECT_THAT(ParseBlockStringLiteral(Input).error().message(),
              Eq("Invalid escaping in \\q"));
  constexpr char InputRaw[] = R"('''
     \#q
     ''')";
  EXPECT_THAT(ParseBlockStringLiteral(InputRaw, 1).error().message(),
              Eq("Invalid escaping in \\#q"));
}

TEST(ParseBlockStringLiteral, OkEmptyString) {
  constexpr char Input[] = R"('''
''')";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(""));
}

TEST(ParseBlockStringLiteral, OkOneLineString) {
  constexpr char Input[] = R"('''
     A block string literal
     ''')";
  constexpr char Expected[] = R"(A block string literal
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkTwoLineString) {
  constexpr char Input[] = R"('''
     A block string literal
       with indent.
     ''')";
  constexpr char Expected[] = R"(A block string literal
  with indent.
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWithFileTypeIndicator) {
  constexpr char Input[] = R"('''carbon
     A block string literal
       with file type indicator.
     ''')";
  constexpr char Expected[] = R"(A block string literal
  with file type indicator.
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWhitespaceAfterOpeningQuotes) {
  constexpr char Input[] = R"('''
     A block string literal
     ''')";
  constexpr char Expected[] = R"(A block string literal
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWithEmptyLines) {
  constexpr char Input[] = R"('''
     A block string literal

       with

       empty

       lines.
     ''')";
  constexpr char Expected[] = R"(A block string literal

  with

  empty

  lines.
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWithSlashNewlineEscape) {
  constexpr char Input[] = R"('''
     A block string literal\
     ''')";
  constexpr char Expected[] = "A block string literal";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWithDoubleSlashNewline) {
  constexpr char Input[] = R"('''
     A block string literal\\
     ''')";
  constexpr char Expected[] = R"(A block string literal\
)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkWithTripleSlashNewline) {
  constexpr char Input[] = R"('''
     A block string literal\\\
     ''')";
  constexpr char Expected[] = R"(A block string literal\)";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(ParseBlockStringLiteral, OkMultipleSlashes) {
  constexpr char Input[] = R"('''
     A block string literal\
     \
     \
     \
     ''')";
  constexpr char Expected[] = "A block string literal";
  EXPECT_THAT(*ParseBlockStringLiteral(Input), Eq(Expected));
}

TEST(BuildCStrArgs, NoArgs) {
  llvm::OwningArrayRef<char> storage;
  auto result = BuildCStrArgs("tool", {}, storage);
  ASSERT_THAT(result.size(), Eq(1));
  EXPECT_THAT(result[0], StrEq("tool"));
}

TEST(BuildCStrArgs, OneArg) {
  llvm::OwningArrayRef<char> storage;
  auto result = BuildCStrArgs("tool", {"arg1"}, storage);
  ASSERT_THAT(result.size(), Eq(2));
  EXPECT_THAT(result[0], StrEq("tool"));
  EXPECT_THAT(result[1], StrEq("arg1"));
}

TEST(BuildCStrArgs, MultipleArgs) {
  llvm::OwningArrayRef<char> storage;
  auto result = BuildCStrArgs("tool", {"arg1", "arg2"}, storage);
  ASSERT_THAT(result.size(), Eq(3));
  EXPECT_THAT(result[0], StrEq("tool"));
  EXPECT_THAT(result[1], StrEq("arg1"));
  EXPECT_THAT(result[2], StrEq("arg2"));
}

TEST(BuildCStrArgsWithPrefix, NoArgs) {
  llvm::OwningArrayRef<char> storage;
  auto result = BuildCStrArgs("tool", {}, {}, storage);
  ASSERT_THAT(result.size(), Eq(1));
  EXPECT_THAT(result[0], StrEq("tool"));
}

TEST(BuildCStrArgsWithPrefix, PrefixOnly) {
  llvm::OwningArrayRef<char> storage;
  std::string prefix_args[] = {"p_arg1", "p_arg2"};
  auto result = BuildCStrArgs("tool", prefix_args, {}, storage);
  ASSERT_THAT(result.size(), Eq(3));
  EXPECT_THAT(result[0], StrEq("tool"));
  EXPECT_THAT(result[1], Eq(prefix_args[0].c_str()));
  EXPECT_THAT(result[2], Eq(prefix_args[1].c_str()));
}

TEST(BuildCStrArgsWithPrefix, ArgsOnly) {
  llvm::OwningArrayRef<char> storage;
  auto result = BuildCStrArgs("tool", {}, {"arg1", "arg2"}, storage);
  ASSERT_THAT(result.size(), Eq(3));
  EXPECT_THAT(result[0], StrEq("tool"));
  EXPECT_THAT(result[1], StrEq("arg1"));
  EXPECT_THAT(result[2], StrEq("arg2"));
}

TEST(BuildCStrArgsWithPrefix, BothPrefixAndArgs) {
  llvm::OwningArrayRef<char> storage;
  std::string prefix_args[] = {"p_arg1", "p_arg2"};
  auto result = BuildCStrArgs("tool", prefix_args, {"arg1", "arg2"}, storage);
  ASSERT_THAT(result.size(), Eq(5));
  EXPECT_THAT(result[0], StrEq("tool"));
  EXPECT_THAT(result[1], Eq(prefix_args[0].c_str()));
  EXPECT_THAT(result[2], Eq(prefix_args[1].c_str()));
  EXPECT_THAT(result[3], StrEq("arg1"));
  EXPECT_THAT(result[4], StrEq("arg2"));
}

}  // namespace
}  // namespace Carbon