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

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

#include "Tests/ScanFloatLiteralTests.h"

using namespace tests;

ScanFloatLiteralTests::ScanFloatLiteralTests():
    TestSuit("ScanFloatLiteralTests", {
        TestCase("scanSmallDecimalFloat", [&]() {
            // Given
            string sourceCode = "0.5";
            long double expected = 0.5;

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

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

        TestCase("scanBigDecimalFloat", [&]() {
            // Given
            string sourceCode = "101.1";
            long double expected = 101.1;

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

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

        TestCase("scanInvalidDots", [&]() {
            // Given
            string sourceCode = "1.123.456";
            long double expected1 = 1.123;
            Punctuator expected2 = Punctuator::DOT;
            long long expected3 = 456;

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

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

            auto token3 = scanner.next();
            auto literal3 = getValue<Literal>(token3);
            auto result3 = getValue<long long>(literal3);

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

        TestCase("scanDecimalFloatLiteralWithUnderscore", [&]() {
            // Given
            string sourceCode = "0.000_1";
            long double expected = 0.0001;

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

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

        TestCase("scanDecimalFloatLiteralWithUnderscores", [&]() {
            // Given
            string sourceCode = "1_000.000_100_500";
            long double expected = 1000.0001005;

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

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

        TestCase("scanDecimalFloatLiteralWithExponent", [&]() {
            // Given
            string sourceCode = "1.2e1";
            long double expected = 12.0;

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

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

        TestCase("scanDecimalFloatLiteralWithSignedExponent", [&]() {
            // Given
            string sourceCode = "1.2e+1";
            long double expected = 12.0;

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

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

        TestCase("scanDecimalFloatLiteralWithoutFractionWithExponent", [&]() {
            // Given
            string sourceCode = "1e1";
            long double expected = 10.0;

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

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

        TestCase("scanDecimalFloatLiteralWithoutFractionWithSignedExponent", [&]() {
            // Given
            string sourceCode = "1e+1";
            long double expected = 10.0;

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

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

        TestCase("scanHexadecimalFloatLiteral", [&]() {
            // Given
            string sourceCode = "0xF.1";
            long double expected = 0xF.1p0;

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

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

        TestCase("scanHexadecimalFloatLiteralWithExponent", [&]() {
            // Given
            string sourceCode = "0xF.Fp1";
            long double expected = 0xF.Fp1;

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

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

        TestCase("scanHexadecimalFloatLiteralWithSignedExponent", [&]() {
            // Given
            string sourceCode = "0xF.Fp+1";
            long double expected = 0xF.Fp1;

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

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

        TestCase("scanHexadecimalFloatLiteralWithoutFractionWithExponent", [&]() {
            // Given
            string sourceCode = "0xFp1";
            long double expected = 0xFp1;

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

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

        TestCase("scanHexadecimalFloatLiteralWithoutFractionWithSignedExponent", [&]() {
            // Given
            string sourceCode = "0xFp+1";
            long double expected = 0xFp1;

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

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