mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Chandler Carruth
eecbb7e508
This keeps the allocations cheap and simplifies the code. It was inspired by the need to expand param files, but no functionality changed yet.
300 lines
9.4 KiB
C++
300 lines
9.4 KiB
C++
// 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"
|
|
#include "llvm/Support/Allocator.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::BumpPtrAllocator alloc;
|
|
auto result = BuildCStrArgs("tool", {}, alloc);
|
|
ASSERT_THAT(result.size(), Eq(1));
|
|
EXPECT_THAT(result[0], StrEq("tool"));
|
|
}
|
|
|
|
TEST(BuildCStrArgs, OneArg) {
|
|
llvm::BumpPtrAllocator alloc;
|
|
auto result = BuildCStrArgs("tool", {"arg1"}, alloc);
|
|
ASSERT_THAT(result.size(), Eq(2));
|
|
EXPECT_THAT(result[0], StrEq("tool"));
|
|
EXPECT_THAT(result[1], StrEq("arg1"));
|
|
}
|
|
|
|
TEST(BuildCStrArgs, MultipleArgs) {
|
|
llvm::BumpPtrAllocator alloc;
|
|
auto result = BuildCStrArgs("tool", {"arg1", "arg2"}, alloc);
|
|
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::BumpPtrAllocator alloc;
|
|
auto result = BuildCStrArgs("tool", {}, {}, alloc);
|
|
ASSERT_THAT(result.size(), Eq(1));
|
|
EXPECT_THAT(result[0], StrEq("tool"));
|
|
}
|
|
|
|
TEST(BuildCStrArgsWithPrefix, PrefixOnly) {
|
|
llvm::BumpPtrAllocator alloc;
|
|
std::string prefix_args[] = {"p_arg1", "p_arg2"};
|
|
auto result = BuildCStrArgs("tool", prefix_args, {}, alloc);
|
|
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::BumpPtrAllocator alloc;
|
|
auto result = BuildCStrArgs("tool", {}, {"arg1", "arg2"}, alloc);
|
|
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::BumpPtrAllocator alloc;
|
|
std::string prefix_args[] = {"p_arg1", "p_arg2"};
|
|
auto result = BuildCStrArgs("tool", prefix_args, {"arg1", "arg2"}, alloc);
|
|
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
|