location_test.cpp

Branch :
Show log
Commit
Author : Jamie Madill
Date : 2018-10-03 07:35:09
Hash : c3bef3e7
Message : Allow 'defined' in define in non-WebGL. This is needed to pass dEQP conformance. Several of the harder dEQP tests around this behaviour are excluded from the mustpass list. This is presumably because the behaviours weren't implemented portably. Nevertheless we need to support conformant behaviour for GLES 2.0 Contexts for the most simple uses. This also leaves the error behaviour intact for WebGL specs. Bug: angleproject:1335 Change-Id: Ia80b4f71475efa928488ee6c2ee35c566d4602d4 Reviewed-on: https://chromium-review.googlesource.com/c/1242013 Reviewed-by: Olli Etuaho <oetuaho@nvidia.com> Reviewed-by: Jamie Madill <jmadill@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
src/tests/preprocessor_tests/location_test.cpp
//
// 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"

namespace angle
{

class LocationTest : public PreprocessorTest
{
protected:
  LocationTest() : PreprocessorTest(SH_GLES2_SPEC) {}

  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, nullptr, loc);
}

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

    SCOPED_TRACE("String0_Line2");
    expectLocation(1, &str, nullptr, 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, nullptr, 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, nullptr, loc);
}

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

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

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

    ASSERT_TRUE(mPreprocessor.init(1, &str, nullptr));
    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, nullptr, loc);
}

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

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

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

    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, nullptr));

    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, nullptr));

    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, nullptr, loc);
}

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

    SCOPED_TRACE("ValidLineDirective2");
    expectLocation(1, &str, nullptr, 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, nullptr, 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, nullptr, 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, nullptr, loc);
}

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

    SCOPED_TRACE("LineDirectiveWithMacro");
    expectLocation(1, &str, nullptr, 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, nullptr, 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, nullptr, loc);
}

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

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

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

// Test for an error being generated when the line number overflows - regular version
TEST_F(LocationTest, LineOverflowRegular)
{
    const char *str = "#line 0x7FFFFFFF\n\n";

    ASSERT_TRUE(mPreprocessor.init(1, &str, nullptr));

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

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

// Test for an error being generated when the line number overflows - inside /* */ comment version
TEST_F(LocationTest, LineOverflowInComment)
{
    const char *str = "#line 0x7FFFFFFF\n/*\n*/";

    ASSERT_TRUE(mPreprocessor.init(1, &str, nullptr));

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

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

// Test for an error being generated when the line number overflows - inside \n continuation
// version
TEST_F(LocationTest, LineOverflowInContinuationN)
{
    const char *str = "#line 0x7FFFFFFF\n \\\n\n";

    ASSERT_TRUE(mPreprocessor.init(1, &str, nullptr));

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

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

// Test for an error being generated when the line number overflows - inside \r\n continuation
// version
TEST_F(LocationTest, LineOverflowInContinuationRN)
{
    const char *str = "#line 0x7FFFFFFF\n \\\r\n\n";

    ASSERT_TRUE(mPreprocessor.init(1, &str, nullptr));

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

    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, nullptr));

    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, nullptr, 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));

}  // namespace angle
kc3-lang/angle/src/tests/preprocessor_tests/location_test.cpp

Commit

kc3-lang/angle /src/tests/preprocessor_tests/location_test.cpp
