//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#include "PreprocessorTest.h"
#include "compiler/preprocessor/Token.h"

class LocationTest : public PreprocessorTest
{
protected:
    void expectLocation(int count,
                        const char* const string[],
                        const int length[],
                        const pp::SourceLocation& location)
    {
        ASSERT_TRUE(mPreprocessor.init(count, string, length));

        pp::Token token;
        mPreprocessor.lex(&token);
        EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
        EXPECT_EQ("foo", token.text);

        EXPECT_EQ(location.file, token.location.file);
        EXPECT_EQ(location.line, token.location.line);
    }
};

TEST_F(LocationTest, String0_Line1)
{
    const char* str = "foo";
    pp::SourceLocation loc(0, 1);

    SCOPED_TRACE("String0_Line1");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, String0_Line2)
{
    const char* str = "\nfoo";
    pp::SourceLocation loc(0, 2);

    SCOPED_TRACE("String0_Line2");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, String1_Line1)
{
    const char* const str[] = {"\n\n", "foo"};
    pp::SourceLocation loc(1, 1);

    SCOPED_TRACE("String1_Line1");
    expectLocation(2, str, NULL, loc);
}

TEST_F(LocationTest, String1_Line2)
{
    const char* const str[] = {"\n\n", "\nfoo"};
    pp::SourceLocation loc(1, 2);

    SCOPED_TRACE("String1_Line2");
    expectLocation(2, str, NULL, loc);
}

TEST_F(LocationTest, NewlineInsideCommentCounted)
{
    const char* str = "/*\n\n*/foo";
    pp::SourceLocation loc(0, 3);

    SCOPED_TRACE("NewlineInsideCommentCounted");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, ErrorLocationAfterComment)
{
    const char* str = "/*\n\n*/@";

    ASSERT_TRUE(mPreprocessor.init(1, &str, NULL));
    EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_INVALID_CHARACTER,
                                    pp::SourceLocation(0, 3),
                                    "@"));

    pp::Token token;
    mPreprocessor.lex(&token);
}

// The location of a token straddling two or more strings is that of the
// first character of the token.

TEST_F(LocationTest, TokenStraddlingTwoStrings)
{
    const char* const str[] = {"f", "oo"};
    pp::SourceLocation loc(0, 1);

    SCOPED_TRACE("TokenStraddlingTwoStrings");
    expectLocation(2, str, NULL, loc);
}

TEST_F(LocationTest, TokenStraddlingThreeStrings)
{
    const char* const str[] = {"f", "o", "o"};
    pp::SourceLocation loc(0, 1);

    SCOPED_TRACE("TokenStraddlingThreeStrings");
    expectLocation(3, str, NULL, loc);
}

TEST_F(LocationTest, EndOfFileWithoutNewline)
{
    const char* const str[] = {"foo"};
    ASSERT_TRUE(mPreprocessor.init(1, str, NULL));

    pp::Token token;
    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
    EXPECT_EQ("foo", token.text);
    EXPECT_EQ(0, token.location.file);
    EXPECT_EQ(1, token.location.line);

    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::LAST, token.type);
    EXPECT_EQ(0, token.location.file);
    EXPECT_EQ(1, token.location.line);
}

TEST_F(LocationTest, EndOfFileAfterNewline)
{
    const char* const str[] = {"foo\n"};
    ASSERT_TRUE(mPreprocessor.init(1, str, NULL));

    pp::Token token;
    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
    EXPECT_EQ("foo", token.text);
    EXPECT_EQ(0, token.location.file);
    EXPECT_EQ(1, token.location.line);

    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::LAST, token.type);
    EXPECT_EQ(0, token.location.file);
    EXPECT_EQ(2, token.location.line);
}

TEST_F(LocationTest, EndOfFileAfterEmptyString)
{
    const char* const str[] = {"foo\n", "\n", ""};
    ASSERT_TRUE(mPreprocessor.init(3, str, NULL));

    pp::Token token;
    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
    EXPECT_EQ("foo", token.text);
    EXPECT_EQ(0, token.location.file);
    EXPECT_EQ(1, token.location.line);

    mPreprocessor.lex(&token);
    EXPECT_EQ(pp::Token::LAST, token.type);
    EXPECT_EQ(2, token.location.file);
    EXPECT_EQ(1, token.location.line);
}

TEST_F(LocationTest, ValidLineDirective1)
{
    const char* str = "#line 10\n"
                      "foo";
    pp::SourceLocation loc(0, 10);

    SCOPED_TRACE("ValidLineDirective1");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, ValidLineDirective2)
{
    const char* str = "#line 10 20\n"
                      "foo";
    pp::SourceLocation loc(20, 10);

    SCOPED_TRACE("ValidLineDirective2");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveCommentsIgnored)
{
    const char* str = "/* bar */"
                      "#"
                      "/* bar */"
                      "line"
                      "/* bar */"
                      "10"
                      "/* bar */"
                      "20"
                      "/* bar */"
                      "// bar   "
                      "\n"
                      "foo";
    pp::SourceLocation loc(20, 10);

    SCOPED_TRACE("LineDirectiveCommentsIgnored");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveWithMacro1)
{
    const char* str = "#define L 10\n"
                      "#define F(x) x\n"
                      "#line L F(20)\n"
                      "foo";
    pp::SourceLocation loc(20, 10);

    SCOPED_TRACE("LineDirectiveWithMacro1");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveWithMacro2)
{
    const char* str = "#define LOC 10 20\n"
                      "#line LOC\n"
                      "foo";
    pp::SourceLocation loc(20, 10);

    SCOPED_TRACE("LineDirectiveWithMacro2");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveWithPredefinedMacro)
{
    const char* str = "#line __LINE__ __FILE__\n"
                      "foo";
    pp::SourceLocation loc(0, 1);

    SCOPED_TRACE("LineDirectiveWithMacro");
    expectLocation(1, &str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveNewlineBeforeStringBreak)
{
    const char* const str[] = {"#line 10 20\n", "foo"};
    // String number is incremented after it is set by the line directive.
    // Also notice that line number is reset after the string break.
    pp::SourceLocation loc(21, 1);

    SCOPED_TRACE("LineDirectiveNewlineBeforeStringBreak");
    expectLocation(2, str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveNewlineAfterStringBreak)
{
    const char* const str[] = {"#line 10 20", "\nfoo"};
    // String number is incremented before it is set by the line directive.
    pp::SourceLocation loc(20, 10);

    SCOPED_TRACE("LineDirectiveNewlineAfterStringBreak");
    expectLocation(2, str, NULL, loc);
}

TEST_F(LocationTest, LineDirectiveMissingNewline)
{
    const char* str = "#line 10";
    ASSERT_TRUE(mPreprocessor.init(1, &str, NULL));

    using testing::_;
    // Error reported about EOF.
    EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_EOF_IN_DIRECTIVE, _, _));

    pp::Token token;
    mPreprocessor.lex(&token);
}

struct LineTestParam
{
    const char* str;
    pp::Diagnostics::ID id;
};

class InvalidLineTest : public LocationTest,
                        public testing::WithParamInterface<LineTestParam>
{
};

TEST_P(InvalidLineTest, Identified)
{
    LineTestParam param = GetParam();
    ASSERT_TRUE(mPreprocessor.init(1, &param.str, NULL));

    using testing::_;
    // Invalid line directive call.
    EXPECT_CALL(mDiagnostics, print(param.id, pp::SourceLocation(0, 1), _));

    pp::Token token;
    mPreprocessor.lex(&token);
}

static const LineTestParam kParams[] = {
    {"#line\n", pp::Diagnostics::PP_INVALID_LINE_DIRECTIVE},
    {"#line foo\n", pp::Diagnostics::PP_INVALID_LINE_NUMBER},
    {"#line defined(foo)\n", pp::Diagnostics::PP_INVALID_LINE_NUMBER},
    {"#line 10 foo\n", pp::Diagnostics::PP_INVALID_FILE_NUMBER},
    {"#line 10 20 foo\n", pp::Diagnostics::PP_UNEXPECTED_TOKEN},
    {"#line 0xffffffff\n", pp::Diagnostics::PP_INTEGER_OVERFLOW},
    {"#line 10 0xffffffff\n", pp::Diagnostics::PP_INTEGER_OVERFLOW}};

INSTANTIATE_TEST_CASE_P(All, InvalidLineTest, testing::ValuesIn(kParams));

struct LineExpressionTestParam
{
    const char *expression;
    int expectedLine;
};

class LineExpressionTest : public LocationTest,
                           public testing::WithParamInterface<LineExpressionTestParam>
{
};

TEST_P(LineExpressionTest, ExpressionEvaluation)
{
    LineExpressionTestParam param = GetParam();
    const char *strs[3] = {"#line ", param.expression, "\nfoo"};

    pp::SourceLocation loc(2, param.expectedLine);

    expectLocation(3, strs, NULL, loc);
}

static const LineExpressionTestParam kParamsLineExpressionTest[] = {
    {"1 + 2", 3},
    {"5 - 3", 2},
    {"7 * 11", 77},
    {"20 / 10", 2},
    {"10 % 5", 0},
    {"7 && 3", 1},
    {"7 || 0", 1},
    {"11 == 11", 1},
    {"11 != 11", 0},
    {"11 > 7", 1},
    {"11 < 7", 0},
    {"11 >= 7", 1},
    {"11 <= 7", 0},
    {"!11", 0},
    {"-1", -1},
    {"+9", 9},
    {"(1 + 2) * 4", 12},
    {"3 | 5", 7},
    {"3 ^ 5", 6},
    {"3 & 5", 1},
    {"~5", ~5},
    {"2 << 3", 16},
    {"16 >> 2", 4}};

INSTANTIATE_TEST_CASE_P(All, LineExpressionTest, testing::ValuesIn(kParamsLineExpressionTest));
