openmw/apps/components_tests/fx/lexer.cpp

#include <components/fx/lexer.hpp>

#include <gtest/gtest.h>

namespace
{
    using namespace testing;
    using namespace fx::Lexer;

    struct LexerTest : Test
    {
    };

    struct LexerSingleTokenTest : Test
    {
        template <class Token>
        void test()
        {
            const std::string content = std::string(Token::repr);
            Lexer lexer(content);

            EXPECT_TRUE(std::holds_alternative<Token>(lexer.next()));
        }
    };

    TEST_F(LexerSingleTokenTest, single_token_shared)
    {
        test<Shared>();
    }
    TEST_F(LexerSingleTokenTest, single_token_technique)
    {
        test<Technique>();
    }
    TEST_F(LexerSingleTokenTest, single_token_render_target)
    {
        test<Render_Target>();
    }
    TEST_F(LexerSingleTokenTest, single_token_vertex)
    {
        test<Vertex>();
    }
    TEST_F(LexerSingleTokenTest, single_token_fragment)
    {
        test<Fragment>();
    }
    TEST_F(LexerSingleTokenTest, single_token_compute)
    {
        test<Compute>();
    }
    TEST_F(LexerSingleTokenTest, single_token_sampler_1d)
    {
        test<Sampler_1D>();
    }
    TEST_F(LexerSingleTokenTest, single_token_sampler_2d)
    {
        test<Sampler_2D>();
    }
    TEST_F(LexerSingleTokenTest, single_token_sampler_3d)
    {
        test<Sampler_3D>();
    }
    TEST_F(LexerSingleTokenTest, single_token_true)
    {
        test<True>();
    }
    TEST_F(LexerSingleTokenTest, single_token_false)
    {
        test<False>();
    }
    TEST_F(LexerSingleTokenTest, single_token_vec2)
    {
        test<Vec2>();
    }
    TEST_F(LexerSingleTokenTest, single_token_vec3)
    {
        test<Vec3>();
    }
    TEST_F(LexerSingleTokenTest, single_token_vec4)
    {
        test<Vec4>();
    }

    TEST(LexerTest, peek_whitespace_only_content_should_be_eof)
    {
        Lexer lexer(R"(

        )");

        EXPECT_TRUE(std::holds_alternative<Eof>(lexer.peek()));
    }

    TEST(LexerTest, float_with_no_prefixed_digits)
    {
        Lexer lexer(R"(
            0.123;
        )");

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<Float>(token));
        EXPECT_FLOAT_EQ(std::get<Float>(token).value, 0.123f);
    }

    TEST(LexerTest, float_with_alpha_prefix)
    {
        Lexer lexer(R"(
            abc.123;
        )");

        EXPECT_TRUE(std::holds_alternative<Literal>(lexer.next()));

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<Float>(token));
        EXPECT_FLOAT_EQ(std::get<Float>(token).value, 0.123f);
    }

    TEST(LexerTest, float_with_numeric_prefix)
    {
        Lexer lexer(R"(
            123.123;
        )");

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<Float>(token));
        EXPECT_FLOAT_EQ(std::get<Float>(token).value, 123.123f);
    }

    TEST(LexerTest, int_should_not_be_float)
    {
        Lexer lexer(R"(
            123
        )");

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<Integer>(token));
        EXPECT_EQ(std::get<Integer>(token).value, 123);
    }

    TEST(LexerTest, simple_string)
    {
        Lexer lexer(R"(
            "test string"
        )");

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<String>(token));

        std::string parsed = std::string(std::get<String>(token).value);
        EXPECT_EQ("test string", parsed);
    }

    TEST(LexerTest, fail_on_unterminated_double_quotes)
    {
        Lexer lexer(R"(
            "unterminated string'
        )");

        EXPECT_THROW(lexer.next(), LexerException);
    }

    TEST(LexerTest, multiline_strings_with_single_quotes)
    {
        Lexer lexer(R"(
            "string that is
                on multiple with 'single quotes'
            and correctly terminated!"
        )");

        auto token = lexer.next();
        EXPECT_TRUE(std::holds_alternative<String>(token));
    }

    TEST(LexerTest, fail_on_unterminated_double_quotes_with_multiline_strings)
    {
        Lexer lexer(R"(
            "string that is
                on multiple with 'single quotes'
            and but is unterminated :(
        )");

        EXPECT_THROW(lexer.next(), LexerException);
    }

    TEST(LexerTest, jump_with_single_nested_bracket)
    {
        const std::string content = R"(
                #version 120

                void main()
                {
                    return 0;
                }})";

        const std::string expected = content.substr(0, content.size() - 1);

        Lexer lexer(content);

        auto block = lexer.jump();

        EXPECT_NE(block, std::nullopt);
        EXPECT_EQ(expected, std::string(block.value()));
    }

    TEST(LexerTest, jump_with_single_line_comments_and_mismatching_brackets)
    {
        const std::string content = R"(
                #version 120

                void main()
                {
                    // }
                    return 0;
                }})";

        const std::string expected = content.substr(0, content.size() - 1);

        Lexer lexer(content);

        auto block = lexer.jump();

        EXPECT_NE(block, std::nullopt);
        EXPECT_EQ(expected, std::string(block.value()));
    }

    TEST(LexerTest, jump_with_multi_line_comments_and_mismatching_brackets)
    {
        const std::string content = R"(
                #version 120

                void main()
                {
                    /*
                        }
                    */
                    return 0;
                }})";

        const std::string expected = content.substr(0, content.size() - 1);

        Lexer lexer(content);

        auto block = lexer.jump();

        EXPECT_NE(block, std::nullopt);
        EXPECT_EQ(expected, std::string(block.value()));
    }

    TEST(LexerTest, immediate_closed_blocks)
    {
        Lexer lexer(R"(block{})");

        EXPECT_TRUE(std::holds_alternative<Literal>(lexer.next()));
        EXPECT_TRUE(std::holds_alternative<Open_bracket>(lexer.next()));
        auto block = lexer.jump();
        EXPECT_TRUE(block.has_value());
        EXPECT_TRUE(block.value().empty());
        EXPECT_TRUE(std::holds_alternative<Close_bracket>(lexer.next()));
    }

}