lib/Tests/ScanIntegerLiteralTests.cpp - main - thomas-king/Scanner

lib/Tests/ScanIntegerLiteralTests.cpp
292 строки9 KB
Ace Rodstin
Replace GoogleTest with UnitTest.
02 ноя 2023, 18:07
02 ноя 2023, 18:078350eca
//
//  ScanIntegerLiteralTests.cpp
//  Scanner
//
//  Created by Ace Rodstin on 11/2/23.
//  Updated by Ace Rodstin on 11/2/23.
//
//  Copyright © 2023 Ace Rodstin. All rights reserved.
//

#include "Tests/ScanIntegerLiteralTests.h"

using namespace tests;

ScanIntegerLiteralTests::ScanIntegerLiteralTests():
    TestSuit("ScanIntegerLiteralTests", {
        TestCase("scanDecimalIntegerZero", [&]() {
            // Given
            string sourceCode = "0";
            long long expected = 0;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanDecimalInteger", [&]() {
            // Given
            string sourceCode = "1";
            long long expected = 1;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanDecimalLiteralWithInvalidCharacter", [&]() {
            // Given
            string sourceCode = "1Z";
            long long expected1 = 1;
            string expected2 = "Z";

            // When
            Scanner scanner { sourceCode };
            auto token1 = scanner.next();
            auto literal1 = getValue<Literal>(token1);
            auto result1 = getValue<long long>(literal1);

            auto token2 = scanner.next();
            auto result2 = getValue<string>(token2);

            // Then
            assertEqual(result1, expected1);
            assertEqual(result2, expected2);
        }),

        TestCase("scanDecimalIntegerLiteralWithUnderscore", [&]() {
            // Given
            string sourceCode = "1_000";
            long long expected = 1000;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanDecimalIntegerLiteralWithUnderscores", [&]() {
            // Given
            string sourceCode = "1_000_000";
            long long expected = 1000000;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanParseBinaryIntegerLiteral", [&]() {
            // Given
            string sourceCode = "0b1";
            long long expected = 0b1;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanBinaryIntegerLiteralWithInvalidCharacter", [&]() {
            // Given
            string sourceCode = "0bZ";
            long long expected1 = 0;
            string expected2 = "Z";

            // When
            Scanner scanner { sourceCode };
            auto token1 = scanner.next();
            auto literal1 = getValue<Literal>(token1);
            auto result1 = getValue<long long>(literal1);

            auto token2 = scanner.next();
            auto result2 = getValue<string>(token2);

            // Then
            assertEqual(result1, expected1);
            assertEqual(result2, expected2);
        }),

        TestCase("scanBinaryIntegerLiteralWithUnderscore", [&]() {
            // Given
            string sourceCode = "0b1_0";
            long long expected = 0b10;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanBinaryIntegerLiteralWithUnderscores", [&]() {
            // Given
            string sourceCode = "0b_1111_0000_1111";
            long long expected = 0b111100001111;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanParseOctalIntegerLiteral", [&]() {
            // Given
            string sourceCode = "0o7";
            long long expected = 07;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanOctalIntegerLiteralWithInvalidCharacter", [&]() {
            // Given
            string sourceCode = "0oZ";
            long long expected1 = 0;
            string expected2 = "Z";

            // When
            Scanner scanner { sourceCode };
            auto token1 = scanner.next();
            auto literal1 = getValue<Literal>(token1);
            auto result1 = getValue<long long>(literal1);

            auto token2 = scanner.next();
            auto result2 = getValue<string>(token2);

            // Then
            assertEqual(result1, expected1);
            assertEqual(result2, expected2);
        }),

        TestCase("scanOctalIntegerLiteralWithUnderscore", [&]() {
            // Given
            string sourceCode = "0o_7";
            long long expected = 07;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanOctalIntegerLiteralWithUnderscores", [&]() {
            // Given
            string sourceCode = "0o_7777_0000_5555";
            long long expected = 0777700005555;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanParseHexadecimalIntegerLiteral", [&]() {
            // Given
            string sourceCode = "0xF";
            long long expected = 0xF;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanHexadecimalIntegerLiteralWithInvalidCharacter", [&]() {
            // Given
            string sourceCode = "0xZ";
            long long expected1 = 0;
            string expected2 = "Z";

            // When
            Scanner scanner { sourceCode };
            auto token1 = scanner.next();
            auto literal1 = getValue<Literal>(token1);
            auto result1 = getValue<long long>(literal1);

            auto token2 = scanner.next();
            auto result2 = getValue<string>(token2);

            // Then
            assertEqual(result1, expected1);
            assertEqual(result2, expected2);
        }),

        TestCase("scanHexadecimalIntegerLiteralWithUnderscore", [&]() {
            // Given
            string sourceCode = "0x_7";
            long long expected = 0x7;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),

        TestCase("scanHexadecimalIntegerLiteralWithUnderscores", [&]() {
            // Given
            string sourceCode = "0x_FFFF_AAAA_5555";
            long long expected = 0xFFFFAAAA5555;

            // When
            Scanner scanner { sourceCode };
            auto token = scanner.next();
            auto literal = getValue<Literal>(token);
            auto result = getValue<long long>(literal);

            // Then
            assertEqual(result, expected);
        }),
    })
{}