// Copyright 2020 The Tint Authors.
//
// Licensed 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 "src/reader/wgsl/lexer.h"

#include <limits>

#include "gtest/gtest.h"

namespace tint {
namespace reader {
namespace wgsl {
namespace {

using LexerTest = testing::Test;

TEST_F(LexerTest, Empty) {
  Lexer l("");
  auto t = l.next();
  EXPECT_TRUE(t.IsEof());
}

TEST_F(LexerTest, Skips_Whitespace) {
  Lexer l("\t\r\n\t    ident\t\n\t  \r ");

  auto t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.line(), 2u);
  EXPECT_EQ(t.column(), 6u);
  EXPECT_EQ(t.to_str(), "ident");

  t = l.next();
  EXPECT_TRUE(t.IsEof());
}

TEST_F(LexerTest, Skips_Comments) {
  Lexer l(R"(#starts with comment
ident1 #ends with comment
# blank line
 ident2)");

  auto t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.line(), 2u);
  EXPECT_EQ(t.column(), 1u);
  EXPECT_EQ(t.to_str(), "ident1");

  t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.line(), 4u);
  EXPECT_EQ(t.column(), 2u);
  EXPECT_EQ(t.to_str(), "ident2");

  t = l.next();
  EXPECT_TRUE(t.IsEof());
}

TEST_F(LexerTest, StringTest_Parse) {
  Lexer l(R"(id "this is string content" id2)");

  auto t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.to_str(), "id");
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());

  t = l.next();
  EXPECT_TRUE(t.IsStringLiteral());
  EXPECT_EQ(t.to_str(), "this is string content");
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(4u, t.column());

  t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.to_str(), "id2");
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(29u, t.column());
}

TEST_F(LexerTest, StringTest_Unterminated) {
  Lexer l(R"(id "this is string content)");

  auto t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.to_str(), "id");
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());

  t = l.next();
  EXPECT_TRUE(t.IsStringLiteral());
  EXPECT_EQ(t.to_str(), "this is string content");

  t = l.next();
  EXPECT_TRUE(t.IsEof());
}

struct FloatData {
  const char* input;
  float result;
};
inline std::ostream& operator<<(std::ostream& out, FloatData data) {
  out << std::string(data.input);
  return out;
}
using FloatTest = testing::TestWithParam<FloatData>;
TEST_P(FloatTest, Parse) {
  auto params = GetParam();
  Lexer l(std::string(params.input));

  auto t = l.next();
  EXPECT_TRUE(t.IsFloatLiteral());
  EXPECT_EQ(t.to_f32(), params.result);
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());

  t = l.next();
  EXPECT_TRUE(t.IsEof());
}
INSTANTIATE_TEST_SUITE_P(LexerTest,
                         FloatTest,
                         testing::Values(FloatData{"0.0", 0.0f},
                                         FloatData{"0.", 0.0f},
                                         FloatData{".0", 0.0f},
                                         FloatData{"5.7", 5.7f},
                                         FloatData{"5.", 5.f},
                                         FloatData{".7", .7f},
                                         FloatData{"-0.0", 0.0f},
                                         FloatData{"-.0", 0.0f},
                                         FloatData{"-0.", 0.0f},
                                         FloatData{"-5.7", -5.7f},
                                         FloatData{"-5.", -5.f},
                                         FloatData{"-.7", -.7f},
                                         FloatData{"0.2e+12", 0.2e12f},
                                         FloatData{"1.2e-5", 1.2e-5f},
                                         FloatData{"2.57e23", 2.57e23f},
                                         FloatData{"2.5e+0", 2.5f},
                                         FloatData{"2.5e-0", 2.5f}));

using FloatTest_Invalid = testing::TestWithParam<const char*>;
TEST_P(FloatTest_Invalid, Handles) {
  Lexer l(GetParam());

  auto t = l.next();
  EXPECT_FALSE(t.IsFloatLiteral());
}
INSTANTIATE_TEST_SUITE_P(LexerTest,
                         FloatTest_Invalid,
                         testing::Values(".",
                                         "-.",
                                         "2.5e+256",
                                         "-2.5e+127",
                                         "2.5e-300",
                                         "2.5e 12",
                                         "2.5e+ 123"));

using IdentifierTest = testing::TestWithParam<const char*>;
TEST_P(IdentifierTest, Parse) {
  Lexer l(GetParam());

  auto t = l.next();
  EXPECT_TRUE(t.IsIdentifier());
  EXPECT_EQ(t.line(), 1u);
  EXPECT_EQ(t.column(), 1u);
  EXPECT_EQ(t.to_str(), GetParam());
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    IdentifierTest,
    testing::Values("test01", "_test_", "test_", "_test", "_01", "_test01"));

TEST_F(LexerTest, IdentifierTest_DoesNotStartWithNumber) {
  Lexer l("01test");

  auto t = l.next();
  EXPECT_FALSE(t.IsIdentifier());
}

struct HexSignedIntData {
  const char* input;
  int32_t result;
};
inline std::ostream& operator<<(std::ostream& out, HexSignedIntData data) {
  out << std::string(data.input);
  return out;
}

using IntegerTest_HexSigned = testing::TestWithParam<HexSignedIntData>;
TEST_P(IntegerTest_HexSigned, Matches) {
  auto params = GetParam();
  Lexer l(std::string(params.input));

  auto t = l.next();
  EXPECT_TRUE(t.IsSintLiteral());
  EXPECT_EQ(t.line(), 1u);
  EXPECT_EQ(t.column(), 1u);
  EXPECT_EQ(t.to_i32(), params.result);
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    IntegerTest_HexSigned,
    testing::Values(
        HexSignedIntData{"0x0", 0},
        HexSignedIntData{"0x42", 66},
        HexSignedIntData{"-0x42", -66},
        HexSignedIntData{"0xeF1Abc9", 250719177},
        HexSignedIntData{"-0x80000000", std::numeric_limits<int32_t>::min()},
        HexSignedIntData{"0x7FFFFFFF", std::numeric_limits<int32_t>::max()}));

TEST_F(LexerTest, IntegerTest_HexSignedTooLarge) {
  Lexer l("0x80000000");
  auto t = l.next();
  ASSERT_TRUE(t.IsError());
  EXPECT_EQ(t.to_str(), "i32 (0x80000000) too large");
}

TEST_F(LexerTest, IntegerTest_HexSignedTooSmall) {
  Lexer l("-0x8000000F");
  auto t = l.next();
  ASSERT_TRUE(t.IsError());
  EXPECT_EQ(t.to_str(), "i32 (-0x8000000F) too small");
}

struct HexUnsignedIntData {
  const char* input;
  uint32_t result;
};
inline std::ostream& operator<<(std::ostream& out, HexUnsignedIntData data) {
  out << std::string(data.input);
  return out;
}
using IntegerTest_HexUnsigned = testing::TestWithParam<HexUnsignedIntData>;
TEST_P(IntegerTest_HexUnsigned, Matches) {
  auto params = GetParam();
  Lexer l(std::string(params.input));

  auto t = l.next();
  EXPECT_TRUE(t.IsUintLiteral());
  EXPECT_EQ(t.line(), 1u);
  EXPECT_EQ(t.column(), 1u);
  EXPECT_EQ(t.to_u32(), params.result);
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    IntegerTest_HexUnsigned,
    testing::Values(HexUnsignedIntData{"0x0u", 0},
                    HexUnsignedIntData{"0x42u", 66},
                    HexUnsignedIntData{"0xeF1Abc9u", 250719177},
                    HexUnsignedIntData{"0x0u",
                                       std::numeric_limits<uint32_t>::min()},
                    HexUnsignedIntData{"0xFFFFFFFFu",
                                       std::numeric_limits<uint32_t>::max()}));

TEST_F(LexerTest, IntegerTest_HexUnsignedTooLarge) {
  Lexer l("0xffffffffffu");
  auto t = l.next();
  ASSERT_TRUE(t.IsError());
  EXPECT_EQ(t.to_str(), "u32 (0xffffffffff) too large");
}

struct UnsignedIntData {
  const char* input;
  uint32_t result;
};
inline std::ostream& operator<<(std::ostream& out, UnsignedIntData data) {
  out << std::string(data.input);
  return out;
}
using IntegerTest_Unsigned = testing::TestWithParam<UnsignedIntData>;
TEST_P(IntegerTest_Unsigned, Matches) {
  auto params = GetParam();
  Lexer l(params.input);

  auto t = l.next();
  EXPECT_TRUE(t.IsUintLiteral());
  EXPECT_EQ(t.to_u32(), params.result);
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());
}
INSTANTIATE_TEST_SUITE_P(LexerTest,
                         IntegerTest_Unsigned,
                         testing::Values(UnsignedIntData{"0u", 0u},
                                         UnsignedIntData{"123u", 123u},
                                         UnsignedIntData{"4294967295u",
                                                         4294967295u}));

struct SignedIntData {
  const char* input;
  int32_t result;
};
inline std::ostream& operator<<(std::ostream& out, SignedIntData data) {
  out << std::string(data.input);
  return out;
}
using IntegerTest_Signed = testing::TestWithParam<SignedIntData>;
TEST_P(IntegerTest_Signed, Matches) {
  auto params = GetParam();
  Lexer l(params.input);

  auto t = l.next();
  EXPECT_TRUE(t.IsSintLiteral());
  EXPECT_EQ(t.to_i32(), params.result);
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    IntegerTest_Signed,
    testing::Values(SignedIntData{"0", 0},
                    SignedIntData{"-2", -2},
                    SignedIntData{"2", 2},
                    SignedIntData{"123", 123},
                    SignedIntData{"2147483647", 2147483647},
                    SignedIntData{"-2147483648", -2147483648LL}));

using IntegerTest_Invalid = testing::TestWithParam<const char*>;
TEST_P(IntegerTest_Invalid, Parses) {
  Lexer l(GetParam());

  auto t = l.next();
  EXPECT_FALSE(t.IsSintLiteral());
  EXPECT_FALSE(t.IsUintLiteral());
}
INSTANTIATE_TEST_SUITE_P(LexerTest,
                         IntegerTest_Invalid,
                         testing::Values("2147483648", "4294967296u"));

struct TokenData {
  const char* input;
  Token::Type type;
};
inline std::ostream& operator<<(std::ostream& out, TokenData data) {
  out << std::string(data.input);
  return out;
}
using PunctuationTest = testing::TestWithParam<TokenData>;
TEST_P(PunctuationTest, Parses) {
  auto params = GetParam();
  Lexer l(params.input);

  auto t = l.next();
  EXPECT_TRUE(t.Is(params.type));
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());

  t = l.next();
  EXPECT_EQ(1 + std::string(params.input).size(), t.column());
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    PunctuationTest,
    testing::Values(TokenData{"&", Token::Type::kAnd},
                    TokenData{"&&", Token::Type::kAndAnd},
                    TokenData{"->", Token::Type::kArrow},
                    TokenData{"[[", Token::Type::kAttrLeft},
                    TokenData{"]]", Token::Type::kAttrRight},
                    TokenData{"/", Token::Type::kForwardSlash},
                    TokenData{"!", Token::Type::kBang},
                    TokenData{"[", Token::Type::kBracketLeft},
                    TokenData{"]", Token::Type::kBracketRight},
                    TokenData{"{", Token::Type::kBraceLeft},
                    TokenData{"}", Token::Type::kBraceRight},
                    TokenData{":", Token::Type::kColon},
                    TokenData{",", Token::Type::kComma},
                    TokenData{"=", Token::Type::kEqual},
                    TokenData{"==", Token::Type::kEqualEqual},
                    TokenData{">", Token::Type::kGreaterThan},
                    TokenData{">=", Token::Type::kGreaterThanEqual},
                    TokenData{"<", Token::Type::kLessThan},
                    TokenData{"<=", Token::Type::kLessThanEqual},
                    TokenData{"%", Token::Type::kMod},
                    TokenData{"!=", Token::Type::kNotEqual},
                    TokenData{"-", Token::Type::kMinus},
                    TokenData{"::", Token::Type::kNamespace},
                    TokenData{".", Token::Type::kPeriod},
                    TokenData{"+", Token::Type::kPlus},
                    TokenData{"|", Token::Type::kOr},
                    TokenData{"||", Token::Type::kOrOr},
                    TokenData{"(", Token::Type::kParenLeft},
                    TokenData{")", Token::Type::kParenRight},
                    TokenData{";", Token::Type::kSemicolon},
                    TokenData{"*", Token::Type::kStar},
                    TokenData{"^", Token::Type::kXor}));

using KeywordTest = testing::TestWithParam<TokenData>;
TEST_P(KeywordTest, Parses) {
  auto params = GetParam();
  Lexer l(params.input);

  auto t = l.next();
  EXPECT_TRUE(t.Is(params.type));
  EXPECT_EQ(1u, t.line());
  EXPECT_EQ(1u, t.column());

  t = l.next();
  EXPECT_EQ(1 + std::string(params.input).size(), t.column());
}
INSTANTIATE_TEST_SUITE_P(
    LexerTest,
    KeywordTest,
    testing::Values(TokenData{"array", Token::Type::kArray},
                    TokenData{"as", Token::Type::kAs},
                    TokenData{"binding", Token::Type::kBinding},
                    TokenData{"block", Token::Type::kBlock},
                    TokenData{"bool", Token::Type::kBool},
                    TokenData{"break", Token::Type::kBreak},
                    TokenData{"builtin", Token::Type::kBuiltin},
                    TokenData{"case", Token::Type::kCase},
                    TokenData{"cast", Token::Type::kCast},
                    TokenData{"compute", Token::Type::kCompute},
                    TokenData{"const", Token::Type::kConst},
                    TokenData{"continue", Token::Type::kContinue},
                    TokenData{"continuing", Token::Type::kContinuing},
                    TokenData{"default", Token::Type::kDefault},
                    TokenData{"else", Token::Type::kElse},
                    TokenData{"elseif", Token::Type::kElseIf},
                    TokenData{"entry_point", Token::Type::kEntryPoint},
                    TokenData{"f32", Token::Type::kF32},
                    TokenData{"fallthrough", Token::Type::kFallthrough},
                    TokenData{"false", Token::Type::kFalse},
                    TokenData{"fn", Token::Type::kFn},
                    TokenData{"fragment", Token::Type::kFragment},
                    TokenData{"function", Token::Type::kFunction},
                    TokenData{"i32", Token::Type::kI32},
                    TokenData{"if", Token::Type::kIf},
                    TokenData{"image", Token::Type::kImage},
                    TokenData{"import", Token::Type::kImport},
                    TokenData{"in", Token::Type::kIn},
                    TokenData{"kill", Token::Type::kKill},
                    TokenData{"location", Token::Type::kLocation},
                    TokenData{"loop", Token::Type::kLoop},
                    TokenData{"mat2x2", Token::Type::kMat2x2},
                    TokenData{"mat2x3", Token::Type::kMat2x3},
                    TokenData{"mat2x4", Token::Type::kMat2x4},
                    TokenData{"mat3x2", Token::Type::kMat3x2},
                    TokenData{"mat3x3", Token::Type::kMat3x3},
                    TokenData{"mat3x4", Token::Type::kMat3x4},
                    TokenData{"mat4x2", Token::Type::kMat4x2},
                    TokenData{"mat4x3", Token::Type::kMat4x3},
                    TokenData{"mat4x4", Token::Type::kMat4x4},
                    TokenData{"offset", Token::Type::kOffset},
                    TokenData{"out", Token::Type::kOut},
                    TokenData{"private", Token::Type::kPrivate},
                    TokenData{"ptr", Token::Type::kPtr},
                    TokenData{"return", Token::Type::kReturn},
                    TokenData{"set", Token::Type::kSet},
                    TokenData{"storage_buffer", Token::Type::kStorageBuffer},
                    TokenData{"struct", Token::Type::kStruct},
                    TokenData{"switch", Token::Type::kSwitch},
                    TokenData{"true", Token::Type::kTrue},
                    TokenData{"type", Token::Type::kType},
                    TokenData{"u32", Token::Type::kU32},
                    TokenData{"uniform", Token::Type::kUniform},
                    TokenData{"uniform_constant",
                              Token::Type::kUniformConstant},
                    TokenData{"var", Token::Type::kVar},
                    TokenData{"vec2", Token::Type::kVec2},
                    TokenData{"vec3", Token::Type::kVec3},
                    TokenData{"vec4", Token::Type::kVec4},
                    TokenData{"vertex", Token::Type::kVertex},
                    TokenData{"void", Token::Type::kVoid},
                    TokenData{"workgroup", Token::Type::kWorkgroup}));

using KeywordTest_Reserved = testing::TestWithParam<const char*>;
TEST_P(KeywordTest_Reserved, Parses) {
  auto* keyword = GetParam();
  Lexer l(keyword);

  auto t = l.next();
  EXPECT_TRUE(t.IsReservedKeyword());
  EXPECT_EQ(t.to_str(), keyword);
}
INSTANTIATE_TEST_SUITE_P(LexerTest,
                         KeywordTest_Reserved,
                         testing::Values("asm",
                                         "bf16",
                                         "do",
                                         "enum",
                                         "f16",
                                         "f64",
                                         "for",
                                         "i8",
                                         "i16",
                                         "i64",
                                         "let",
                                         "premerge",
                                         "typedef",
                                         "u8",
                                         "u16",
                                         "u64",
                                         "unless",
                                         "regardless"));

}  // namespace
}  // namespace wgsl
}  // namespace reader
}  // namespace tint