From cc0f43bc8a6f766359b23dd44a8052a4e1c3bae6 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Sat, 17 Oct 2026 17:05:37 +0200 Subject: [PATCH 1/4] Export CodeBuilderFactory for tests --- src/engine/internal/codebuilderfactory.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/engine/internal/codebuilderfactory.h b/src/engine/internal/codebuilderfactory.h index 4dac2db75..8218f3bc2 100644 --- a/src/engine/internal/codebuilderfactory.h +++ b/src/engine/internal/codebuilderfactory.h @@ -3,11 +3,12 @@ #pragma once #include "icodebuilderfactory.h" +#include "test_export.h" namespace libscratchcpp { -class CodeBuilderFactory : public ICodeBuilderFactory +class LIBSCRATCHCPP_TEST_EXPORT CodeBuilderFactory : public ICodeBuilderFactory { public: static std::shared_ptr instance(); From 37f197d2fa3d31c53e4bb9231c9d9987490f1ddc Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Sat, 17 Oct 2026 17:05:53 +0200 Subject: [PATCH 2/4] Add a generic CodeBuilder test suite --- test/CMakeLists.txt | 1 + test/codegen/CMakeLists.txt | 33 + test/codegen/codebuilder_test.cpp | 3938 +++++++++++++++++++++++++++++ test/codegen/codegentestutils.cpp | 375 +++ test/codegen/codegentestutils.h | 109 + test/codegen/main.cpp | 1 + test/codegen/testfunctions.cpp | 228 ++ test/codegen/testfunctions.h | 63 + test/codegen/testmock.h | 20 + 9 files changed, 4768 insertions(+) create mode 100644 test/codegen/CMakeLists.txt create mode 100644 test/codegen/codebuilder_test.cpp create mode 100644 test/codegen/codegentestutils.cpp create mode 100644 test/codegen/codegentestutils.h create mode 100644 test/codegen/main.cpp create mode 100644 test/codegen/testfunctions.cpp create mode 100644 test/codegen/testfunctions.h create mode 100644 test/codegen/testmock.h diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index b6f51dace..f6cf9531d 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -26,6 +26,7 @@ add_subdirectory(scratchconfiguration) add_subdirectory(assets) add_subdirectory(script) add_subdirectory(extensions) +add_subdirectory(codegen) add_subdirectory(engine) add_subdirectory(clock) add_subdirectory(timer) diff --git a/test/codegen/CMakeLists.txt b/test/codegen/CMakeLists.txt new file mode 100644 index 000000000..0cffa65c1 --- /dev/null +++ b/test/codegen/CMakeLists.txt @@ -0,0 +1,33 @@ +add_library( + codegen_test_functions SHARED + testfunctions.cpp + testfunctions.h + testmock.h +) + +target_link_libraries( + codegen_test_functions + GTest::gtest_main + GTest::gmock_main + scratchcpp + scratchcpp_mocks +) + +add_executable( + codegen_test + main.cpp + codebuilder_test.cpp + codegentestutils.cpp + codegentestutils.h +) + +target_link_libraries( + codegen_test + GTest::gtest_main + GTest::gmock_main + scratchcpp + scratchcpp_mocks + codegen_test_functions +) + +gtest_discover_tests(codegen_test) diff --git a/test/codegen/codebuilder_test.cpp b/test/codegen/codebuilder_test.cpp new file mode 100644 index 000000000..7e16a9c47 --- /dev/null +++ b/test/codegen/codebuilder_test.cpp @@ -0,0 +1,3938 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "codegentestutils.h" + +using namespace libscratchcpp; + +using ::testing::Return; +using ::testing::Eq; + +class CodeBuilderTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(CodeBuilderTest, FunctionCalls) +{ + static const std::vector warpList = { false, true }; + + for (bool warp : warpList) { + ICodeBuilder *builder = m_utils.createBuilder(warp); + + builder->addFunctionCall("test_empty_function", Compiler::StaticType::Void, {}, {}); + + CompilerValue *v = builder->addConstValue("test"); + builder->addFunctionCallWithCtx("test_ctx_function", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + + v = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("1"); + v = builder->addTargetFunctionCall("test_function_1_arg_ret", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); + CompilerValue *v1 = builder->addConstValue("2"); + CompilerValue *v2 = builder->addConstValue("3"); + builder->addTargetFunctionCall("test_function_3_args", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, { v, v1, v2 }); + + v = builder->addConstValue("test"); + v1 = builder->addConstValue("4"); + v2 = builder->addConstValue("5"); + v = builder->addTargetFunctionCall( + "test_function_3_args_ret", + Compiler::StaticType::String, + { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, + { v, v1, v2 }); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(123); + v = builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { v }); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(true); + v = builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(321.5); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + v = builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { v }); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + v = builder->addConstValue("test"); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + v = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + v = builder->addConstValue(true); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + v = builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + std::stringstream s; + s << ctx.get(); + std::string ctxPtr = s.str(); + + const std::string expected = + "empty\n" + ctxPtr + + "\n" + "test\n" + "no_args\n" + "no_args_ret\n" + "1_arg no_args_output\n" + "1_arg_ret 1\n" + "3_args 1_arg_output 2 3\n" + "3_args test 4 5\n" + "1_arg 3_args_output\n" + "123\n" + "1\n" + "321.5\n" + "321.5\n" + "test\n" + "test\n" + "true\n" + "true\n"; + + EXPECT_CALL(m_utils.target(), isStage()).Times(7); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_TRUE(code->isFinished(ctx.get())); + } +} + +TEST_F(CodeBuilderTest, FunctionCallsWithPointers) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + int var = 12; + CompilerValue *v = builder->addConstValue(&var); + v = builder->addTargetFunctionCall("test_function_1_ptr_arg_ret", Compiler::StaticType::Pointer, { Compiler::StaticType::Pointer }, { v }); + + builder->addFunctionCall("test_print_pointer", Compiler::StaticType::Void, { Compiler::StaticType::Pointer }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + std::stringstream s; + s << &m_utils.target(); + std::string ptr = s.str(); + + const std::string expected = "1_arg_ret 12\n" + ptr + "\n"; + + EXPECT_CALL(m_utils.target(), isStage()); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, ConstCasting) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + CompilerValue *v = builder->addConstValue(5.2); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + v = builder->addConstValue("-24.156"); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(true); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(0); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("false"); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("123"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("hello world"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "5.2\n" + "-24.156\n" + "1\n" + "0\n" + "0\n" + "123\n" + "hello world\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ConstCasting_ToMixedTypes) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + CompilerValue *v = builder->addConstValue(true); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Number | Compiler::StaticType::Bool }, { v }); + v = builder->addConstValue(-24.156); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Number | Compiler::StaticType::Bool }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "true\n" + "-24.156\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, RawValueCasting) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Number -> number + CompilerValue *v = builder->addConstValue(5.2); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Number -> bool + v = builder->addConstValue(-24.156); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(0); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Number -> string + v = builder->addConstValue(59.8); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // Bool -> number + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Bool -> bool + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Bool -> string + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // String -> number + v = builder->addConstValue("5.2"); + v = m_utils.callConstFuncForType(ValueType::String, v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // String -> bool + v = builder->addConstValue("abc"); + v = m_utils.callConstFuncForType(ValueType::String, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("false"); + v = m_utils.callConstFuncForType(ValueType::String, v); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // String -> string + v = builder->addConstValue("hello world"); + v = m_utils.callConstFuncForType(ValueType::String, v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "5.2\n" + "1\n" + "0\n" + "59.8\n" + "1\n" + "0\n" + "1\n" + "0\n" + "true\n" + "false\n" + "5.2\n" + "1\n" + "0\n" + "hello world\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ValueCasting_FromNumberBool) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Number | Bool -> number + CompilerValue *v = builder->addConstValue(5.2); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Number | Bool -> bool + v = builder->addConstValue(-24.156); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(0); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Number | Bool -> string + v = builder->addConstValue(4.5); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "5.2\n" + "1\n" + "1\n" + "0\n" + "1\n" + "4.5\n" + "true\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ValueCasting_FromNumberString) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Number | String -> number + CompilerValue *v = builder->addConstValue(42.5); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("123.45"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("not_a_number"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Number | String -> bool + v = builder->addConstValue(0); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(-15.7); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("false"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("hello"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Number | String -> string + v = builder->addConstValue(4.5); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("world"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "42.5\n" + "123.45\n" + "0\n" + "0\n" + "1\n" + "0\n" + "1\n" + "4.5\n" + "world\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ValueCasting_FromBoolString) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Bool | String -> number + CompilerValue *v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("456.78"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("invalid"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Bool | String -> bool + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("false"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("anything"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Bool | String -> string + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("test_string"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "1\n" + "0\n" + "456.78\n" + "0\n" + "1\n" + "0\n" + "0\n" + "1\n" + "true\n" + "false\n" + "test_string\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ValueCasting_FromUnknown) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Unknown -> number + CompilerValue *v = builder->addConstValue(42.5); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("123.45"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("not_a_number"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Unknown -> bool + v = builder->addConstValue(0); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(-15.7); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("false"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("hello"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Unknown -> string + v = builder->addConstValue(4.5); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("world"); + v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // Unknown -> unknown (passthrough) + v = builder->addConstValue(321.5); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + v = builder->addConstValue("test"); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + v = builder->addConstValue(true); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "42.5\n" + "123.45\n" + "1\n" + "0\n" + "0\n" + "1\n" + "1\n" + "0\n" + "1\n" + "4.5\n" + "false\n" + "world\n" + "321.5\n" + "test\n" + "true\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, LocalVariables) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerLocalVariable *var1 = builder->createLocalVariable(Compiler::StaticType::Number); + CompilerLocalVariable *var2 = builder->createLocalVariable(Compiler::StaticType::Number); + CompilerLocalVariable *var3 = builder->createLocalVariable(Compiler::StaticType::Bool); + CompilerLocalVariable *var4 = builder->createLocalVariable(Compiler::StaticType::Bool); + + CompilerValue *v = builder->addConstValue(5); + builder->createLocalVariableWrite(var1, v); + + v = builder->addConstValue(-23.5); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->createLocalVariableWrite(var2, v); + + v = builder->addConstValue(5.2); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->createLocalVariableWrite(var2, v); + + v = builder->addConstValue(false); + builder->createLocalVariableWrite(var3, v); + + v = builder->addConstValue(true); + builder->createLocalVariableWrite(var3, v); + + v = builder->addConstValue(false); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->createLocalVariableWrite(var4, v); + + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var1) }); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var2) }); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var3) }); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var4) }); + + static const std::string expected = + "5\n" + "5.2\n" + "true\n" + "false\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, WriteVariable) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar1 = std::make_shared("", ""); + auto globalVar2 = std::make_shared("", ""); + auto globalVar3 = std::make_shared("", ""); + stage.addVariable(globalVar1); + stage.addVariable(globalVar2); + stage.addVariable(globalVar3); + + auto localVar1 = std::make_shared("", ""); + auto localVar2 = std::make_shared("", ""); + auto localVar3 = std::make_shared("", ""); + auto localVar4 = std::make_shared("", ""); + sprite.addVariable(localVar1); + sprite.addVariable(localVar2); + sprite.addVariable(localVar3); + sprite.addVariable(localVar4); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(5); + builder->createVariableWrite(globalVar1.get(), v); + + v = builder->addConstValue(-23.5); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->createVariableWrite(globalVar2.get(), v); + + v = builder->addConstValue("test"); + builder->createVariableWrite(globalVar3.get(), v); + + v = builder->addConstValue("abc"); + builder->createVariableWrite(localVar1.get(), v); + + v = builder->addConstValue("hello world"); + v = m_utils.callConstFuncForType(ValueType::String, v); + builder->createVariableWrite(localVar1.get(), v); + + v = builder->addConstValue(false); + builder->createVariableWrite(localVar2.get(), v); + + v = builder->addConstValue(true); + v = m_utils.callConstFuncForType(ValueType::Bool, v); + builder->createVariableWrite(localVar3.get(), v); + + v = builder->addConstValue(45.23); + v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); + builder->createVariableWrite(localVar4.get(), v); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_EQ(globalVar1->value(), 5); + ASSERT_EQ(globalVar2->value(), -23.5); + ASSERT_EQ(globalVar3->value(), "test"); + ASSERT_EQ(localVar1->value(), "hello world"); + ASSERT_EQ(localVar2->value(), false); + ASSERT_EQ(localVar3->value(), true); + ASSERT_EQ(localVar4->value(), 45.23); +} + +TEST_F(CodeBuilderTest, Select) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + // Number + CompilerValue *v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue(5.8), builder->addConstValue(-17.42), Compiler::StaticType::Number); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue(5.8), builder->addConstValue(-17.42), Compiler::StaticType::Number); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Bool + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue(true), builder->addConstValue(false), Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue(true), builder->addConstValue(false), Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // String + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue("hello"), builder->addConstValue("world"), Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue("hello"), builder->addConstValue("world"), Compiler::StaticType::String); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // Different types + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue("543"), builder->addConstValue("true"), Compiler::StaticType::Number); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue("543"), builder->addConstValue("true"), Compiler::StaticType::Number); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue(1), builder->addConstValue("false"), Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue(1), builder->addConstValue("false"), Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + // Unknown types + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue("test"), builder->addConstValue(-456.2), Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(false); + v = builder->createSelect(v, builder->addConstValue("abc"), builder->addConstValue(true), Compiler::StaticType::Unknown); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(true); + v = builder->createSelect(v, builder->addConstValue("abc"), builder->addConstValue(true), Compiler::StaticType::String | Compiler::StaticType::Bool); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "5.8\n" + "-17.42\n" + "1\n" + "0\n" + "hello\n" + "world\n" + "543\n" + "0\n" + "1\n" + "0\n" + "test\n" + "true\n" + "abc\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ReadVariable) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar1 = std::make_shared("", "", 87); + auto globalVar2 = std::make_shared("", "", 6.4); + auto globalVar3 = std::make_shared("", "", "abc"); + stage.addVariable(globalVar1); + stage.addVariable(globalVar2); + stage.addVariable(globalVar3); + + auto localVar1 = std::make_shared("", "", false); + auto localVar2 = std::make_shared("", "", true); + auto localVar3 = std::make_shared("", "", "test"); + sprite.addVariable(localVar1); + sprite.addVariable(localVar2); + sprite.addVariable(localVar3); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addVariableValue(globalVar1.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(globalVar2.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(globalVar3.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar1.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar2.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar3.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected; + expected += globalVar1->value().toString() + '\n'; + expected += globalVar2->value().toString() + '\n'; + expected += globalVar3->value().toString() + '\n'; + expected += localVar1->value().toString() + '\n'; + expected += localVar2->value().toString() + '\n'; + expected += localVar3->value().toString() + '\n'; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, SyncVariablesBeforeCallingFunction) +{ + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + + auto var = std::make_shared("", ""); + sprite.addVariable(var); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue("abc"); + builder->createVariableWrite(var.get(), v); + + v = builder->addConstValue(123); + builder->createVariableWrite(var.get(), v); + + builder->addTargetFunctionCall("test_print_first_local_variable", Compiler::StaticType::Void, {}, {}); + + v = builder->addConstValue(456); + builder->createVariableWrite(var.get(), v); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + + ASSERT_EQ(testing::internal::GetCapturedStdout(), "123\n"); +} + +TEST_F(CodeBuilderTest, CastNonRawValueToUnknownType) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto var = std::make_shared("", "", 87); + stage.addVariable(var); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + // Unknown type + CompilerValue *v = builder->addVariableValue(var.get()); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + // Number + v = builder->addConstValue(23.5); + builder->createVariableWrite(var.get(), v); + v = builder->addVariableValue(var.get()); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + // String + v = builder->addConstValue("Hello world"); + builder->createVariableWrite(var.get(), v); + v = builder->addVariableValue(var.get()); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + // Bool + v = builder->addConstValue(true); + builder->createVariableWrite(var.get(), v); + v = builder->addVariableValue(var.get()); + builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); + + std::string expected; + expected += var->value().toString() + '\n'; + expected += "23.5\n"; + expected += "Hello world\n"; + expected += "true\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ClearList) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList1 = std::make_shared("", ""); + auto globalList2 = std::make_shared("", ""); + auto globalList3 = std::make_shared("", ""); + stage.addList(globalList1); + stage.addList(globalList2); + stage.addList(globalList3); + + auto localList1 = std::make_shared("", ""); + auto localList2 = std::make_shared("", ""); + auto localList3 = std::make_shared("", ""); + sprite.addList(localList1); + sprite.addList(localList2); + sprite.addList(localList3); + + globalList1->append(1); + globalList1->append(2); + globalList1->append(3); + strings[globalList1.get()] = globalList1->toString(); + + globalList2->append("Lorem"); + globalList2->append("ipsum"); + globalList2->append(-4.52); + strings[globalList2.get()] = globalList2->toString(); + + globalList3->append(true); + globalList3->append(false); + globalList3->append(true); + strings[globalList3.get()] = globalList3->toString(); + + localList1->append("dolor"); + localList1->append("sit"); + localList1->append("amet"); + strings[localList1.get()] = localList1->toString(); + + localList2->append(10); + localList2->append(9.8); + localList2->append(true); + strings[localList2.get()] = localList2->toString(); + + localList3->append("test"); + localList3->append(1.2); + localList3->append(false); + strings[localList3.get()] = localList3->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + builder->createListClear(globalList1.get()); + builder->createListClear(globalList3.get()); + builder->createListClear(localList1.get()); + builder->createListClear(localList2.get()); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_TRUE(globalList1->empty()); + ASSERT_EQ(globalList2->toString(), strings[globalList2.get()]); + ASSERT_TRUE(globalList3->empty()); + + ASSERT_TRUE(localList1->empty()); + ASSERT_TRUE(localList2->empty()); + ASSERT_EQ(localList3->toString(), strings[localList3.get()]); +} + +TEST_F(CodeBuilderTest, RemoveFromList) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + strings[localList.get()] = localList->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(1); + builder->createListRemove(globalList.get(), v); + + v = builder->addConstValue(-1); + builder->createListRemove(globalList.get(), v); + + v = builder->addConstValue(3); + builder->createListRemove(globalList.get(), v); + + v = builder->addConstValue(3); + builder->createListRemove(localList.get(), v); + + v = builder->addConstValue(-1); + builder->createListRemove(localList.get(), v); + + v = builder->addConstValue(4); + builder->createListRemove(localList.get(), v); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_EQ(globalList->toString(), "13"); + ASSERT_EQ(localList->toString(), "Lorem ipsum dolor"); +} + +TEST_F(CodeBuilderTest, AppendToList) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + strings[localList.get()] = localList->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(1); + builder->createListAppend(globalList.get(), v); + + v = builder->addConstValue("test"); + builder->createListAppend(globalList.get(), v); + + v = builder->addConstValue(3); + builder->createListAppend(localList.get(), v); + + builder->createListClear(localList.get()); + + v = builder->addConstValue(true); + builder->createListAppend(localList.get(), v); + + v = builder->addConstValue(false); + builder->createListAppend(localList.get(), v); + + v = builder->addConstValue("hello world"); + builder->createListAppend(localList.get(), v); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_EQ(globalList->toString(), "1 2 3 1 test"); + ASSERT_EQ(localList->toString(), "true false hello world"); +} + +TEST_F(CodeBuilderTest, InsertToList) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + strings[localList.get()] = localList->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v1 = builder->addConstValue(2); + CompilerValue *v2 = builder->addConstValue(1); + builder->createListInsert(globalList.get(), v1, v2); + + v1 = builder->addConstValue(3); + v2 = builder->addConstValue("test"); + builder->createListInsert(globalList.get(), v1, v2); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(3); + builder->createListInsert(localList.get(), v1, v2); + + builder->createListClear(localList.get()); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(true); + builder->createListInsert(localList.get(), v1, v2); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(false); + builder->createListInsert(localList.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue("hello world"); + builder->createListInsert(localList.get(), v1, v2); + + v1 = builder->addConstValue(3); + v2 = builder->addConstValue("test"); + builder->createListInsert(localList.get(), v1, v2); + + v1 = builder->addConstValue(-1); + v2 = builder->addConstValue(123); + builder->createListInsert(localList.get(), v1, v2); + + v1 = builder->addConstValue(6); + v2 = builder->addConstValue(123); + builder->createListInsert(localList.get(), v1, v2); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_EQ(globalList->toString(), "1 2 1 test 3"); + ASSERT_EQ(localList->toString(), "false hello world true test"); +} + +TEST_F(CodeBuilderTest, ListReplace) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + strings[localList.get()] = localList->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v1 = builder->addConstValue(2); + CompilerValue *v2 = builder->addConstValue(1); + builder->createListReplace(globalList.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue("test"); + builder->createListReplace(globalList.get(), v1, v2); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(3); + builder->createListReplace(localList.get(), v1, v2); + + v1 = builder->addConstValue(2); + v2 = builder->addConstValue(true); + builder->createListReplace(localList.get(), v1, v2); + + v1 = builder->addConstValue(3); + v2 = builder->addConstValue("hello world"); + builder->createListReplace(localList.get(), v1, v2); + + v1 = builder->addConstValue(-1); + v2 = builder->addConstValue(123); + builder->createListReplace(localList.get(), v1, v2); + + v1 = builder->addConstValue(5); + v2 = builder->addConstValue(123); + builder->createListReplace(localList.get(), v1, v2); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + + ASSERT_EQ(globalList->toString(), "1 test 1"); + ASSERT_EQ(localList->toString(), "3 ipsum true hello world"); +} + +TEST_F(CodeBuilderTest, GetListContents) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + std::unordered_map strings; + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + strings[localList.get()] = localList->toString(); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addListContents(globalList.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListContents(localList.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "123\n" + "Lorem ipsum dolor sit\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + ASSERT_EQ(globalList->toString(), "123"); + ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); +} + +TEST_F(CodeBuilderTest, GetListItem) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList1 = std::make_shared("", ""); + sprite.addList(localList1); + + auto localList2 = std::make_shared("", ""); + sprite.addList(localList2); + + auto localList3 = std::make_shared("", ""); + sprite.addList(localList3); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList1->append("Lorem"); + localList1->append("ipsum"); + localList1->append("dolor"); + localList1->append("sit"); + + localList2->append(-564.121); + localList2->append(4257.4); + + localList3->append(true); + localList3->append(false); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + // Global + CompilerValue *v = builder->addConstValue(2); + v = builder->addListItem(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + CompilerValue *v1 = builder->addConstValue(1); + CompilerValue *v2 = builder->addConstValue("test"); + builder->createListReplace(globalList.get(), v1, v2); + + v = builder->addConstValue(0); + v = builder->addListItem(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(-1); + v = builder->addListItem(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(3); + v = builder->addListItem(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // Local 1 + v = builder->addConstValue(0); + v = builder->addListItem(localList1.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(2); + v = builder->addListItem(localList1.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(3); + v = builder->addListItem(localList1.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(-1); + v = builder->addListItem(localList1.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(4); + v = builder->addListItem(localList1.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // Local 2 + v = builder->addConstValue(-1); + v = builder->addListItem(localList2.get(), v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(2); + v = builder->addListItem(localList2.get(), v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Local 3 + v = builder->addConstValue(-1); + v = builder->addListItem(localList3.get(), v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue(2); + v = builder->addListItem(localList3.get(), v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + // Establish number type + builder->createListClear(localList3.get()); + builder->createListAppend(localList3.get(), builder->addConstValue(1.5)); + + // Out-of-range index should still return empty string + v = builder->addConstValue(2); + v = builder->addListItem(localList3.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "3\n" + "1\n" + "\n" + "\n" + "Lorem\n" + "dolor\n" + "sit\n" + "\n" + "\n" + "0\n" + "0\n" + "0\n" + "0\n" + "\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + ASSERT_EQ(globalList->toString(), "1 test 3"); + ASSERT_EQ(localList1->toString(), "Lorem ipsum dolor sit"); + ASSERT_EQ(localList2->toString(), "-564.121 4257.4"); + ASSERT_EQ(localList3->toString(), "1.5"); +} + +TEST_F(CodeBuilderTest, GetListSize) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addListSize(globalList.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListSize(localList.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "3\n" + "4\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + ASSERT_EQ(globalList->toString(), "123"); + ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); +} + +TEST_F(CodeBuilderTest, GetListItemIndex) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(2); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(1); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(0); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + CompilerValue *v1 = builder->addConstValue(1); + CompilerValue *v2 = builder->addConstValue("test"); + builder->createListReplace(globalList.get(), v1, v2); + + v = builder->addConstValue(2); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(1); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("test"); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("abc"); + v = builder->addListItemIndex(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("doLor"); + v = builder->addListItemIndex(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(true); + v = builder->addListItemIndex(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("site"); + v = builder->addListItemIndex(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "1\n" + "0\n" + "-1\n" + "-1\n" + "0\n" + "1\n" + "-1\n" + "2\n" + "-1\n" + "-1\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + ASSERT_EQ(globalList->toString(), "1 test 3"); + ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); +} + +TEST_F(CodeBuilderTest, ListContainsItem) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + globalList->append(1); + globalList->append(2); + globalList->append(3); + + localList->append("Lorem"); + localList->append("ipsum"); + localList->append("dolor"); + localList->append("sit"); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(2); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(1); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(0); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + CompilerValue *v1 = builder->addConstValue(1); + CompilerValue *v2 = builder->addConstValue("test"); + builder->createListReplace(globalList.get(), v1, v2); + + v = builder->addConstValue(2); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(1); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("test"); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("abc"); + v = builder->addListContains(globalList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("doLor"); + v = builder->addListContains(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(true); + v = builder->addListContains(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue("site"); + v = builder->addListContains(localList.get(), v); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + static const std::string expected = + "true\n" + "true\n" + "false\n" + "false\n" + "true\n" + "true\n" + "false\n" + "true\n" + "false\n" + "false\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + ASSERT_EQ(globalList->toString(), "1 test 3"); + ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); +} + +TEST_F(CodeBuilderTest, Yield) +{ + ICodeBuilder *builder; + + auto build = [this, &builder]() { + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + + CompilerValue *v = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->yield(); + + v = builder->addConstValue("1"); + v = builder->addTargetFunctionCall("test_function_1_arg_ret", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); + CompilerValue *v1 = builder->addConstValue("2"); + CompilerValue *v2 = builder->addConstValue(3); + builder->addTargetFunctionCall("test_function_3_args", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, { v, v1, v2 }); + + v = builder->addConstValue("test"); + v1 = builder->addConstValue("4"); + v2 = builder->addConstValue("5"); + v = builder->addTargetFunctionCall( + "test_function_3_args_ret", + Compiler::StaticType::String, + { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, + { v, v1, v2 }); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + }; + + // Without warp + builder = m_utils.createBuilder(false); + build(); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected1 = + "no_args\n" + "no_args_ret\n" + "1_arg no_args_output\n"; + + EXPECT_CALL(m_utils.target(), isStage()).Times(3); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + static const std::string expected2 = + "1_arg_ret 1\n" + "3_args 1_arg_output 2 3\n" + "3_args test 4 5\n" + "1_arg 3_args_output\n"; + + EXPECT_CALL(m_utils.target(), isStage()).Times(4); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2); + ASSERT_TRUE(code->isFinished(ctx.get())); + + // Terminate unfinished coroutine + EXPECT_CALL(m_utils.target(), isStage()).Times(3); + testing::internal::CaptureStdout(); + code->reset(ctx.get()); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + code->kill(ctx.get()); + ASSERT_TRUE(code->isFinished(ctx.get())); + + // Reset unfinished coroutine + EXPECT_CALL(m_utils.target(), isStage()).Times(3); + testing::internal::CaptureStdout(); + code->reset(ctx.get()); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + code->reset(ctx.get()); + + EXPECT_CALL(m_utils.target(), isStage()).Times(3); + testing::internal::CaptureStdout(); + code->reset(ctx.get()); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); // leave unfinished coroutine + + // With warp + builder = m_utils.createBuilder(true); + build(); + code = builder->build(); + ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "no_args\n" + "no_args_ret\n" + "1_arg no_args_output\n" + "1_arg_ret 1\n" + "3_args 1_arg_output 2 3\n" + "3_args test 4 5\n" + "1_arg 3_args_output\n"; + + EXPECT_CALL(m_utils.target(), isStage()).Times(7); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, VariablesAfterSuspend) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar = std::make_shared("", "", 87); + stage.addVariable(globalVar); + + auto localVar = std::make_shared("", "", "test"); + sprite.addVariable(localVar); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, false); + + CompilerValue *v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(true); + builder->createVariableWrite(localVar.get(), v); + + builder->yield(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + } + builder->endLoop(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(0); + builder->createVariableWrite(localVar.get(), v); + + builder->beginLoopCondition(); + v = builder->createCmpLT(builder->addVariableValue(localVar.get()), builder->addConstValue(3)); + builder->beginWhileLoop(v); + builder->endLoop(); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(0); + builder->createVariableWrite(localVar.get(), v); + + builder->beginLoopCondition(); + v = builder->createCmpEQ(builder->addVariableValue(localVar.get()), builder->addConstValue(2)); + builder->beginRepeatUntilLoop(v); + builder->endLoop(); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "hello world\n" + "-4.8\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + ASSERT_FALSE(code->isFinished(ctx.get())); + + globalVar->setValue("hello world"); + localVar->setValue(-4.8); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_FALSE(code->isFinished(ctx.get())); + + globalVar->setValue("test"); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); + ASSERT_FALSE(code->isFinished(ctx.get())); + + globalVar->setValue(true); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "true\n"); + ASSERT_FALSE(code->isFinished(ctx.get())); + + localVar->setValue(1); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); + ASSERT_FALSE(code->isFinished(ctx.get())); + + localVar->setValue("2"); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); + ASSERT_FALSE(code->isFinished(ctx.get())); + + localVar->setValue(3); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "3\n"); + ASSERT_FALSE(code->isFinished(ctx.get())); + + localVar->setValue(1); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); + ASSERT_FALSE(code->isFinished(ctx.get())); + + localVar->setValue(2); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "2\n"); +} + +TEST_F(CodeBuilderTest, ListsAfterSuspend) +{ + + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList1 = std::make_shared("", ""); + stage.addList(globalList1); + + auto globalList2 = std::make_shared("", ""); + stage.addList(globalList2); + + auto localList1 = std::make_shared("", ""); + sprite.addList(localList1); + + auto localList2 = std::make_shared("", ""); + sprite.addList(localList2); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, false); + + builder->createListClear(globalList1.get()); + builder->createListClear(globalList2.get()); + builder->createListClear(localList1.get()); + builder->createListClear(localList2.get()); + + builder->createListAppend(globalList1.get(), builder->addConstValue(1)); + builder->createListAppend(globalList1.get(), builder->addConstValue(2)); + builder->createListAppend(globalList1.get(), builder->addConstValue(3)); + + builder->createListAppend(globalList2.get(), builder->addConstValue(1)); + builder->createListAppend(globalList2.get(), builder->addConstValue(2)); + builder->createListAppend(globalList2.get(), builder->addConstValue(3)); + + builder->createListReplace(globalList2.get(), builder->addConstValue(1), builder->addConstValue(12.5)); + + builder->createListInsert(localList1.get(), builder->addConstValue(0), builder->addConstValue("Lorem")); + builder->createListInsert(localList1.get(), builder->addConstValue(0), builder->addConstValue("ipsum")); + + builder->createListInsert(localList2.get(), builder->addConstValue(0), builder->addConstValue(true)); + builder->createListInsert(localList2.get(), builder->addConstValue(0), builder->addConstValue(false)); + + builder->yield(); + + CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(1)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(globalList1.get(), builder->addConstValue(2)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(globalList2.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(localList1.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(localList1.get(), builder->addConstValue(1)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(localList2.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "2\n" + "test\n" + "12.5\n" + "false\n" + "ipsum\n" + "-5.48\n" + "hello\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + ASSERT_FALSE(code->isFinished(ctx.get())); + + globalList1->replace(2, "test"); + globalList2->replace(0, false); + localList1->replace(1, -5.48); + localList2->replace(0, "hello"); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, IfStatement) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Without else branch (const condition) + CompilerValue *v = builder->addConstValue("true"); + builder->beginIfStatement(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endIf(); + + v = builder->addConstValue("false"); + builder->beginIfStatement(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endIf(); + + // Without else branch (condition returned by function) + CompilerValue *v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + CompilerValue *v2 = builder->addConstValue("no_args_output"); + v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); + builder->beginIfStatement(v); + v = builder->addConstValue(0); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + v2 = builder->addConstValue(""); + v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); + builder->beginIfStatement(v); + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + // With else branch (const condition) + v = builder->addConstValue("true"); + builder->beginIfStatement(v); + v = builder->addConstValue(2); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->beginElseBranch(); + v = builder->addConstValue(3); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + v = builder->addConstValue("false"); + builder->beginIfStatement(v); + v = builder->addConstValue(4); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->beginElseBranch(); + v = builder->addConstValue(5); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + // With else branch (condition returned by function) + v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + v2 = builder->addConstValue("no_args_output"); + v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); + builder->beginIfStatement(v); + v = builder->addConstValue(6); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->beginElseBranch(); + v = builder->addConstValue(7); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + v2 = builder->addConstValue(""); + v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); + builder->beginIfStatement(v); + v = builder->addConstValue(8); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->beginElseBranch(); + v = builder->addConstValue(9); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endIf(); + + // Nested 1 + CompilerValue *str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue(0); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->beginElseBranch(); + { + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + + v = builder->addConstValue(false); + builder->beginIfStatement(v); + builder->beginElseBranch(); + { + v = builder->addConstValue(2); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->endIf(); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + } + builder->endIf(); + } + builder->beginElseBranch(); + { + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(3); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->beginElseBranch(); + { + v = builder->addConstValue(4); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->endIf(); + } + builder->endIf(); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + + // Nested 2 + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue(5); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->beginElseBranch(); + { + v = builder->addConstValue(6); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->endIf(); + } + builder->beginElseBranch(); + { + str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); + + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(7); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->beginElseBranch(); + builder->endIf(); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + } + builder->endIf(); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "no_args\n" + "no_args_ret\n" + "1_arg 0\n" + "no_args_ret\n" + "1_arg 2\n" + "1_arg 5\n" + "no_args_ret\n" + "1_arg 6\n" + "no_args_ret\n" + "1_arg 9\n" + "1_arg 1\n" + "test\n" + "1_arg 2\n" + "test\n" + "test\n" + "1_arg 7\n" + "test\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, IfStatementVariables) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar = std::make_shared("", "", "test"); + stage.addVariable(globalVar); + + auto localVar = std::make_shared("", "", 87); + sprite.addVariable(localVar); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(true); + builder->createVariableWrite(localVar.get(), v); + + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue("hello world"); + builder->createVariableWrite(globalVar.get(), v); + } + builder->endIf(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue("hello world"); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(0); + builder->createVariableWrite(localVar.get(), v); + } + builder->endIf(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(true); + builder->createVariableWrite(globalVar.get(), v); + } + builder->endIf(); + + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue(-8.2); + builder->createVariableWrite(localVar.get(), v); + } + builder->endIf(); + } + builder->endIf(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "hello world\n" + "12.5\n" + "true\n" + "true\n" + "true\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, IfStatementLists) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList1 = std::make_shared("", ""); + stage.addList(globalList1); + + auto globalList2 = std::make_shared("", ""); + stage.addList(globalList2); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, false); + + auto resetLists = [this, builder, globalList1, globalList2, localList]() { + builder->createListClear(globalList1.get()); + builder->createListClear(globalList2.get()); + builder->createListClear(localList.get()); + + builder->createListAppend(globalList1.get(), builder->addConstValue(1)); + builder->createListAppend(globalList1.get(), builder->addConstValue(2)); + + builder->createListAppend(globalList2.get(), builder->addConstValue("hello")); + builder->createListAppend(globalList2.get(), builder->addConstValue("world")); + + builder->createListAppend(localList.get(), builder->addConstValue(false)); + builder->createListAppend(localList.get(), builder->addConstValue(true)); + }; + + auto checkLists = [this, builder, globalList1, globalList2, localList]() { + CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(localList.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + }; + + // if (true) + resetLists(); + + CompilerValue *v, *v1, *v2; + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endIf(); + + checkLists(); + + // if (false) + resetLists(); + + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endIf(); + + checkLists(); + + // if (true) { if (true) { ... }; if (false) { ... } } + resetLists(); + + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue(true); + builder->beginIfStatement(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + } + builder->endIf(); + + v = builder->addConstValue(false); + builder->beginIfStatement(v); + { + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endIf(); + } + builder->endIf(); + + checkLists(); + + std::string expected = + "1\n" + "hello\n" + "false\n" + "1\n" + "world\n" + "false\n" + "1\n" + "hello\n" + "false\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, RepeatLoop) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Const count + CompilerValue *v = builder->addConstValue("-5"); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + v = builder->addConstValue(0); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + v = builder->addConstValue(3); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + v = builder->addConstValue("2.4"); + builder->beginRepeatLoop(v); + v = builder->addConstValue(0); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endLoop(); + + v = builder->addConstValue("2.5"); + builder->beginRepeatLoop(v); + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->endLoop(); + + // Count returned by function + v = builder->addConstValue(2); + v = m_utils.callConstFuncForType(ValueType::Number, v); + builder->beginRepeatLoop(v); + CompilerValue *index = builder->addLoopIndex(); + builder->addTargetFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { index }); + builder->endLoop(); + + // Nested + CompilerValue *str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + } + builder->endLoop(); + + v = builder->addConstValue(2); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(3); + builder->beginRepeatLoop(v); + { + index = builder->addLoopIndex(); + builder->addTargetFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { index }); + } + builder->endLoop(); + } + builder->endLoop(); + + // str should still be allocated + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "no_args\n" + "no_args\n" + "no_args\n" + "1_arg 0\n" + "1_arg 0\n" + "1_arg 1\n" + "1_arg 1\n" + "1_arg 1\n" + "0\n" + "1\n" + "1_arg 1\n" + "test\n" + "1_arg 1\n" + "test\n" + "1_arg 2\n" + "0\n" + "1\n" + "2\n" + "1_arg 1\n" + "test\n" + "1_arg 1\n" + "test\n" + "1_arg 2\n" + "0\n" + "1\n" + "2\n" + "test\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + // Yield + builder = m_utils.createBuilder(false); + + v = builder->addConstValue(3); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + code = builder->build(); + ctx = code->createExecutionContext(&thread); + + static const std::string expected1 = "no_args\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + + for (int i = 0; i < 3; i++) { + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + } + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_TRUE(testing::internal::GetCapturedStdout().empty()); + ASSERT_TRUE(code->isFinished(ctx.get())); + + // No warp no-op loop + builder = m_utils.createBuilder(false); + + v = builder->addConstValue(0); // don't yield + builder->beginRepeatLoop(v); + builder->endLoop(); + + code = builder->build(); + ctx = code->createExecutionContext(&thread); + code->run(ctx.get()); + ASSERT_TRUE(code->isFinished(ctx.get())); + + // Infinite no warp loop + builder = m_utils.createBuilder(false); + + v = builder->addConstValue("Infinity"); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + code = builder->build(); + ctx = code->createExecutionContext(&thread); + + for (int i = 0; i < 10; i++) { + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "no_args\n"); + ASSERT_FALSE(code->isFinished(ctx.get())); + } +} + +TEST_F(CodeBuilderTest, WhileLoop) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Const condition + builder->beginLoopCondition(); + CompilerValue *v = builder->addConstValue("false"); + builder->beginWhileLoop(v); + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + builder->beginLoopCondition(); + v = builder->addConstValue(false); + builder->beginWhileLoop(v); + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + // Condition returned by function + builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); + builder->beginLoopCondition(); + CompilerValue *v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + CompilerValue *v2 = builder->addConstValue(2); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + builder->beginWhileLoop(v); + v = builder->addConstValue(0); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + // Nested + builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); + builder->beginLoopCondition(); + v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + v2 = builder->addConstValue(3); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + builder->beginWhileLoop(v); + { + builder->beginLoopCondition(); + v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + v2 = builder->addConstValue(3); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + builder->beginWhileLoop(v); + { + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); + } + builder->endLoop(); + + v = builder->addConstValue(2); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->beginLoopCondition(); + v = builder->addConstValue(false); + builder->beginWhileLoop(v); + { + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + } + builder->endLoop(); + } + builder->endLoop(); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "1_arg 0\n" + "1_arg 0\n" + "1_arg 1\n" + "1_arg 1\n" + "1_arg 1\n" + "1_arg 2\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + // Yield + builder = m_utils.createBuilder(false); + + builder->beginLoopCondition(); + v = builder->addConstValue(true); + builder->beginWhileLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + code = builder->build(); + ctx = code->createExecutionContext(&thread); + + static const std::string expected1 = "no_args\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + + for (int i = 0; i < 10; i++) { + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + } +} + +TEST_F(CodeBuilderTest, RepeatUntilLoop) +{ + ICodeBuilder *builder = m_utils.createBuilder(true); + + // Const condition + builder->beginLoopCondition(); + CompilerValue *v = builder->addConstValue("true"); + builder->beginRepeatUntilLoop(v); + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + builder->beginLoopCondition(); + v = builder->addConstValue(true); + builder->beginRepeatUntilLoop(v); + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + // Condition returned by function + builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); + builder->beginLoopCondition(); + CompilerValue *v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + CompilerValue *v2 = builder->addConstValue(2); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + builder->beginRepeatUntilLoop(v); + v = builder->addConstValue(0); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + // Nested + builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); + builder->beginLoopCondition(); + v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + v2 = builder->addConstValue(3); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + builder->beginRepeatUntilLoop(v); + { + builder->beginLoopCondition(); + v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); + v2 = builder->addConstValue(3); + v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); + v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + builder->beginRepeatUntilLoop(v); + { + v = builder->addConstValue(1); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); + } + builder->endLoop(); + + v = builder->addConstValue(2); + builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->beginLoopCondition(); + v = builder->addConstValue(true); + builder->beginRepeatUntilLoop(v); + { + builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); + } + builder->endLoop(); + } + builder->endLoop(); + + auto code = builder->build(); + Script script(&m_utils.target(), nullptr, nullptr); + script.setCode(code); + Thread thread(&m_utils.target(), nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + static const std::string expected = + "1_arg 0\n" + "1_arg 0\n" + "1_arg 1\n" + "1_arg 1\n" + "1_arg 1\n" + "1_arg 2\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + + // Yield + builder = m_utils.createBuilder(false); + + builder->beginLoopCondition(); + v = builder->addConstValue(false); + builder->beginRepeatUntilLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + code = builder->build(); + ctx = code->createExecutionContext(&thread); + + static const std::string expected1 = "no_args\n"; + + EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); + + for (int i = 0; i < 10; i++) { + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + } +} + +TEST_F(CodeBuilderTest, LoopVariables) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar = std::make_shared("", "", "test"); + stage.addVariable(globalVar); + + auto localVar = std::make_shared("", "", 87); + auto counter1 = std::make_shared("", ""); + auto counter2 = std::make_shared("", ""); + sprite.addVariable(localVar); + sprite.addVariable(counter1); + sprite.addVariable(counter2); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(true); + builder->createVariableWrite(localVar.get(), v); + + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createVariableWrite(globalVar.get(), v); + } + builder->endLoop(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(12.5); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(0); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createVariableWrite(globalVar.get(), v); + + v = builder->addConstValue(0); + builder->createVariableWrite(localVar.get(), v); + } + builder->endLoop(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addConstValue(0); + builder->createVariableWrite(counter1.get(), v); + + builder->beginLoopCondition(); + CompilerValue *v1 = builder->addVariableValue(counter1.get()); + CompilerValue *v2 = builder->addConstValue(5); + v = builder->createCmpLT(v1, v2); + builder->beginWhileLoop(v); + { + v = builder->addConstValue(0); + builder->createVariableWrite(counter2.get(), v); + + builder->beginLoopCondition(); + v1 = builder->addVariableValue(counter2.get()); + v2 = builder->addConstValue(3); + v = builder->createCmpEQ(v1, v2); + builder->beginRepeatUntilLoop(v); + { + v = builder->addConstValue(true); + builder->createVariableWrite(globalVar.get(), v); + + v1 = builder->addVariableValue(counter2.get()); + v2 = builder->addConstValue(1); + v = builder->createAdd(v1, v2); + builder->createVariableWrite(counter2.get(), v); + } + builder->endLoop(); + + builder->beginLoopCondition(); + v = builder->addConstValue(false); + builder->beginWhileLoop(v); + { + v = builder->addConstValue(-8.2); + builder->createVariableWrite(localVar.get(), v); + } + builder->endLoop(); + + v1 = builder->addVariableValue(counter1.get()); + v2 = builder->addConstValue(1); + v = builder->createAdd(v1, v2); + builder->createVariableWrite(counter1.get(), v); + } + builder->endLoop(); + + builder->beginLoopCondition(); + v = builder->addConstValue(true); + builder->beginRepeatUntilLoop(v); + { + v = builder->addConstValue(-8.2); + builder->createVariableWrite(localVar.get(), v); + } + builder->endLoop(); + + v = builder->addVariableValue(globalVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "hello world\n" + "12.5\n" + "true\n" + "true\n" + "true\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, VariableLoopTypeAnalysis) +{ + // This just makes sure the type analyzer is used correctly + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalVar = std::make_shared("", ""); + stage.addVariable(globalVar); + + auto localVar = std::make_shared("", ""); + sprite.addVariable(localVar); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(5.25); + builder->createVariableWrite(localVar.get(), v); + + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + // Type is unknown here because a string is assigned later + v = builder->addVariableValue(localVar.get()); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addConstValue("test"); + builder->createVariableWrite(localVar.get(), v); + } + builder->endLoop(); + + std::string expected = + "5.25\n" + "0\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, LoopLists) +{ + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList1 = std::make_shared("", ""); + stage.addList(globalList1); + + auto globalList2 = std::make_shared("", ""); + stage.addList(globalList2); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + auto counter1 = std::make_shared("", ""); + auto counter2 = std::make_shared("", ""); + sprite.addVariable(counter1); + sprite.addVariable(counter2); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + auto resetLists = [this, builder, globalList1, globalList2, localList]() { + builder->createListClear(globalList1.get()); + builder->createListClear(globalList2.get()); + builder->createListClear(localList.get()); + + builder->createListAppend(globalList1.get(), builder->addConstValue(1)); + builder->createListAppend(globalList1.get(), builder->addConstValue(2)); + + builder->createListAppend(globalList2.get(), builder->addConstValue("hello")); + builder->createListAppend(globalList2.get(), builder->addConstValue("world")); + + builder->createListAppend(localList.get(), builder->addConstValue(false)); + builder->createListAppend(localList.get(), builder->addConstValue(true)); + }; + + auto checkLists = [this, builder, globalList1, globalList2, localList]() { + CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(localList.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + }; + + // repeat (2) + resetLists(); + + CompilerValue *v, *v1, *v2; + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endLoop(); + + checkLists(); + + // repeat(0) + resetLists(); + + v = builder->addConstValue(0); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endLoop(); + + checkLists(); + + // while (counter1 < 5) { ... until (counter2 == 3) {... counter2++ }; while (false) { ... }; counter1++ } + resetLists(); + + v = builder->addConstValue(0); + builder->createVariableWrite(counter1.get(), v); + + builder->beginLoopCondition(); + v1 = builder->addVariableValue(counter1.get()); + v2 = builder->addConstValue(5); + v = builder->createCmpLT(v1, v2); + builder->beginWhileLoop(v); + { + v = builder->addConstValue(0); + builder->createVariableWrite(counter2.get(), v); + + builder->beginLoopCondition(); + v1 = builder->addVariableValue(counter2.get()); + v2 = builder->addConstValue(3); + v = builder->createCmpEQ(v1, v2); + builder->beginRepeatUntilLoop(v); + { + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + + v1 = builder->addVariableValue(counter2.get()); + v2 = builder->addConstValue(1); + v = builder->createAdd(v1, v2); + builder->createVariableWrite(counter2.get(), v); + } + builder->endLoop(); + + builder->beginLoopCondition(); + v = builder->addConstValue(false); + builder->beginWhileLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + } + builder->endLoop(); + + v1 = builder->addVariableValue(counter1.get()); + v2 = builder->addConstValue(1); + v = builder->createAdd(v1, v2); + builder->createVariableWrite(counter1.get(), v); + } + builder->endLoop(); + + checkLists(); + + // until (true) + resetLists(); + + builder->beginLoopCondition(); + v = builder->addConstValue(true); + builder->beginRepeatUntilLoop(v); + { + v = builder->addConstValue("hello world"); + builder->createListAppend(globalList1.get(), v); + + v1 = builder->addConstValue(0); + v2 = builder->addConstValue(8.5); + builder->createListInsert(globalList2.get(), v1, v2); + + v1 = builder->addConstValue(1); + v2 = builder->addConstValue(-4.25); + builder->createListReplace(localList.get(), v1, v2); + } + builder->endLoop(); + + checkLists(); + + std::string expected = + "1\n" + "8.5\n" + "false\n" + "1\n" + "world\n" + "false\n" + "1\n" + "8.5\n" + "false\n" + "1\n" + "world\n" + "false\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + ; + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, ListLoopTypeAnalysis) +{ + // This just makes sure the type analyzer is used correctly + Stage stage; + Sprite sprite; + sprite.setEngine(&m_utils.engine()); + EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); + + auto globalList = std::make_shared("", ""); + stage.addList(globalList); + + auto localList = std::make_shared("", ""); + sprite.addList(localList); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + builder->createListClear(localList.get()); + + CompilerValue *v = builder->addConstValue(5.25); + builder->createListAppend(localList.get(), v); + + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + // Type is unknown here because a string is added later + v = builder->createSub(builder->addListSize(localList.get()), builder->addConstValue(1)); + v = builder->addListItem(localList.get(), v); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addListItemIndex(localList.get(), builder->addConstValue(5.25)); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addListContains(localList.get(), builder->addConstValue(5.25)); + builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); + + v = builder->addConstValue("test"); + builder->createListAppend(localList.get(), v); + } + builder->endLoop(); + + std::string expected = + "5.25\n" + "0\n" + "1\n" + "0\n" + "0\n" + "1\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, StopNoWarp) +{ + Sprite sprite; + ICodeBuilder *builder = m_utils.createBuilder(&sprite, false); + + builder->beginLoopCondition(); + CompilerValue *v = builder->addConstValue(true); + builder->beginWhileLoop(v); + builder->createStop(); + builder->endLoop(); + + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + + std::string expected = ""; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, StopWarp) +{ + Sprite sprite; + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *v = builder->addConstValue(true); + builder->beginIfStatement(v); + builder->createStop(); + builder->endIf(); + + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + + std::string expected = ""; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, StopAndReturn) +{ + Sprite sprite; + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->createStop(); + + std::string expected = "no_args\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, MultipleScripts) +{ + Sprite sprite; + + // Script 1 + ICodeBuilder *builder = m_utils.createBuilder(&sprite, nullptr); + + CompilerValue *v = builder->addConstValue("script1"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code1 = builder->build(); + + // Script 2 + builder = m_utils.createBuilder(&sprite, nullptr); + + v = builder->addConstValue("script2"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code2 = builder->build(); + + Script script1(&sprite, nullptr, nullptr); + script1.setCode(code1); + Thread thread1(&sprite, nullptr, &script1); + auto ctx = code1->createExecutionContext(&thread1); + + testing::internal::CaptureStdout(); + code1->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "script1\n"); + + Script script2(&sprite, nullptr, nullptr); + script2.setCode(code2); + Thread thread2(&sprite, nullptr, &script2); + ctx = code2->createExecutionContext(&thread2); + + testing::internal::CaptureStdout(); + code2->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), "script2\n"); +} + +TEST_F(CodeBuilderTest, Procedures) +{ + Sprite sprite; + auto var = std::make_shared("", ""); + auto list = std::make_shared("", ""); + sprite.addVariable(var); + sprite.addList(list); + + // Procedure 1 + BlockPrototype prototype1; + prototype1.setProcCode("procedure 1 %s %s %b"); + prototype1.setArgumentNames({ "any type 1", "any type 2", "bool" }); + prototype1.setArgumentIds({ "a", "b", "c" }); + prototype1.setWarp(false); + ICodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype1); + + CompilerValue *v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); + builder->endLoop(); + + builder->createVariableWrite(var.get(), builder->addProcedureArgument("any type 1")); + builder->createListClear(list.get()); + builder->createListAppend(list.get(), builder->addProcedureArgument("any type 2")); + + v = builder->addVariableValue(var.get()); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addListItem(list.get(), builder->addConstValue(0)); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + v = builder->addProcedureArgument("bool"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); + + v = builder->addProcedureArgument("invalid"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc1 = builder->build(); + + // Procedure 2 + BlockPrototype prototype2; + prototype2.setProcCode("procedure 2"); + prototype2.setWarp(true); + builder = m_utils.createBuilder(&sprite, &prototype2); + + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + builder->createProcedureCall(&prototype1, { builder->addConstValue(-652.3), builder->addConstValue(false), builder->addConstValue(true) }); + builder->endLoop(); + + auto proc2 = builder->build(); + + // Script + builder = m_utils.createBuilder(&sprite, false); + builder->createProcedureCall(&prototype1, { builder->addConstValue("test"), builder->addConstValue(true), builder->addConstValue(false) }); + builder->createProcedureCall(&prototype2, {}); + + v = builder->addProcedureArgument("test"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected1 = "no_args\n"; + + std::string expected2 = + "test\n" + "true\n" + "false\n" + "0\n" + "0\n"; + + std::string expected3 = + "no_args\n" + "no_args\n" + "-652.3\n" + "false\n" + "true\n" + "1\n" + "0\n" + "no_args\n" + "no_args\n" + "-652.3\n" + "false\n" + "true\n" + "1\n" + "0\n" + "0\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2 + expected3); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, UndefinedProcedure) +{ + Sprite sprite; + + BlockPrototype prototype; + prototype.setProcCode("procedure 1 %s %s %b"); + prototype.setArgumentNames({ "any type 1", "any type 2", "bool" }); + prototype.setArgumentIds({ "a", "b", "c" }); + prototype.setWarp(false); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, false); + builder->createProcedureCall(&prototype, { builder->addConstValue("test"), builder->addConstValue(true), builder->addConstValue(false) }); + + CompilerValue *v = builder->addConstValue("test"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = "test\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, ProcedureThreadStop_Warp) +{ + Sprite sprite; + + // Inner procedure (proc2): prints "inner_before", then stops the thread + BlockPrototype prototype2; + prototype2.setProcCode("proc2"); + prototype2.setWarp(true); + ICodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); + + CompilerValue *v = builder->addConstValue("inner_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createThreadStop(); + + // This should NOT execute + v = builder->addConstValue("inner_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc2Code = builder->build(); + + // Outer procedure (proc1): prints "outer_before", calls proc2, then prints "outer_after" + BlockPrototype prototype1; + prototype1.setProcCode("proc1"); + prototype1.setWarp(true); + builder = m_utils.createBuilder(&sprite, &prototype1); + + v = builder->addConstValue("outer_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createProcedureCall(&prototype2, {}); + + // This should NOT execute (thread was stopped by proc2) + v = builder->addConstValue("outer_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc1Code = builder->build(); + + // Root script: prints "script_before", calls proc1, then prints "script_after" + builder = m_utils.createBuilder(&sprite, true); + + v = builder->addConstValue("script_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createProcedureCall(&prototype1, {}); + + // This should NOT execute (thread was stopped by proc2 via proc1) + v = builder->addConstValue("script_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "script_before\n" + "outer_before\n" + "inner_before\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, ProcedureThreadStop_NonWarp) +{ + Sprite sprite; + + // Inner procedure (proc2): prints "inner_before", then stops the thread + BlockPrototype prototype2; + prototype2.setProcCode("proc2"); + prototype2.setWarp(false); + ICodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); + + CompilerValue *v = builder->addConstValue("inner_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createThreadStop(); + + // This should NOT execute + v = builder->addConstValue("inner_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc2Code = builder->build(); + + // Outer procedure (proc1): prints "outer_before", calls proc2, then prints "outer_after" + BlockPrototype prototype1; + prototype1.setProcCode("proc1"); + prototype1.setWarp(false); + builder = m_utils.createBuilder(&sprite, &prototype1); + + v = builder->addConstValue("outer_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createProcedureCall(&prototype2, {}); + + // This should NOT execute (thread was stopped by proc2) + v = builder->addConstValue("outer_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc1Code = builder->build(); + + // Root script: prints "script_before", calls proc1, then prints "script_after" + builder = m_utils.createBuilder(&sprite, false); + + v = builder->addConstValue("script_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + builder->createProcedureCall(&prototype1, {}); + + // This should NOT execute (thread was stopped by proc2 via proc1) + v = builder->addConstValue("script_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + std::string expected = + "script_before\n" + "outer_before\n" + "inner_before\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, ProcedureThreadStop_NonWarp_AfterYield) +{ + Sprite sprite; + + // Inner procedure (proc2): yields via a repeat loop, then stops the thread + // This exercises the coroutine resume path where the sentinel must propagate + BlockPrototype prototype2; + prototype2.setProcCode("proc2"); + prototype2.setWarp(false); + + ICodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); + CompilerValue *v = builder->addConstValue("inner_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + // This repeat loop causes the coroutine to suspend (yield) on each iteration + v = builder->addConstValue(2); + builder->beginRepeatLoop(v); + { + v = builder->addConstValue("inner_loop"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + } + builder->endLoop(); + + // After the loop completes, stop the thread + builder->createThreadStop(); + + // This should NOT execute + v = builder->addConstValue("inner_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto proc2Code = builder->build(); + + // Outer procedure (proc1): calls proc2 + BlockPrototype prototype1; + prototype1.setProcCode("proc1"); + prototype1.setWarp(false); + + builder = m_utils.createBuilder(&sprite, &prototype1); + + v = builder->addConstValue("outer_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->createProcedureCall(&prototype2, {}); + + // This should NOT execute (thread was stopped by proc2) + v = builder->addConstValue("outer_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + auto proc1Code = builder->build(); + + // Root script: calls proc1 + builder = m_utils.createBuilder(&sprite, false); + v = builder->addConstValue("script_before"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + builder->createProcedureCall(&prototype1, {}); + + // This should NOT execute (thread was stopped by proc2 via proc1) + v = builder->addConstValue("script_after"); + builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + // First run: enters the repeat loop in proc2, yields after first iteration + std::string expected1 = + "script_before\n" + "outer_before\n" + "inner_before\n" + "inner_loop\n"; + + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); + ASSERT_FALSE(code->isFinished(ctx.get())); + + // Second run: second iteration of the repeat loop, yields again + std::string expected2 = "inner_loop\n"; + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2); + ASSERT_FALSE(code->isFinished(ctx.get())); + + // Third run: loop is done, createThreadStop() fires, sentinel must propagate + // through the coroutine resume path back to the caller + // Neither "inner_after", "outer_after", nor "script_after" should print + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); + ASSERT_TRUE(code->isFinished(ctx.get())); +} + +TEST_F(CodeBuilderTest, Print) +{ + Sprite sprite; + ICodeBuilder *builder = m_utils.createBuilder(&sprite, true); + + CompilerValue *ret = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); + builder->createPrint(ret); + builder->createPrint(builder->addConstValue("\n")); + + std::string expected = "no_args_ret\nno_args_output\n"; + + auto code = builder->build(); + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + testing::internal::CaptureStdout(); + code->run(ctx.get()); + ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); +} + +TEST_F(CodeBuilderTest, HatPredicates) +{ + Sprite sprite; + + // Predicate 1 + ICodeBuilder *builder = m_utils.createPredicateBuilder(&sprite); + + builder->addConstValue(true); + + auto code1 = builder->build(); + + // Predicate 2 + builder = m_utils.createPredicateBuilder(&sprite); + + CompilerValue *v = builder->addConstValue(false); + builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); + + auto code2 = builder->build(); + + Script script1(&sprite, nullptr, nullptr); + script1.setCode(code1); + Thread thread1(&sprite, nullptr, &script1); + auto ctx = code1->createExecutionContext(&thread1); + + ASSERT_TRUE(code1->runPredicate(ctx.get())); + + Script script2(&sprite, nullptr, nullptr); + script2.setCode(code2); + Thread thread2(&sprite, nullptr, &script2); + ctx = code2->createExecutionContext(&thread2); + + ASSERT_FALSE(code2->runPredicate(ctx.get())); +} + +TEST_F(CodeBuilderTest, Reporters) +{ + Sprite sprite; + auto var = std::make_shared("", ""); + var->setValue("Hello world!"); + sprite.addVariable(var); + + // Reporter 1 + ICodeBuilder *builder = m_utils.createReporterBuilder(&sprite); + + builder->addConstValue(-45.23); + + auto code1 = builder->build(); + + // Reporter 2 + builder = m_utils.createReporterBuilder(&sprite); + + CompilerValue *v = builder->addConstValue("test"); + builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); + + auto code2 = builder->build(); + + // Reporter 3 + builder = m_utils.createReporterBuilder(&sprite); + builder->addVariableValue(var.get()); + + auto code3 = builder->build(); + + // Reporter 4 + builder = m_utils.createReporterBuilder(&sprite); + int pointee; + builder->addConstValue(&pointee); + + auto code4 = builder->build(); + + // Reporter 5 + builder = m_utils.createReporterBuilder(&sprite); + v = builder->addConstValue(&pointee); + builder->addFunctionCall("test_const_pointer", Compiler::StaticType::Pointer, { Compiler::StaticType::Pointer }, { v }); + + auto code5 = builder->build(); + + auto runReporter = [&sprite](std::shared_ptr code) { + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread1(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread1); + return code->runReporter(ctx.get()); + }; + + // 1 + ValueData ret = runReporter(code1); + ASSERT_TRUE(value_isNumber(&ret)); + ASSERT_EQ(value_toDouble(&ret), -45.23); + value_free(&ret); + + // 2 + ret = runReporter(code2); + ASSERT_EQ(Value(ret).toString(), "test"); + value_free(&ret); + + // 3 + ret = runReporter(code3); + var->setValue("abc"); // the string should be copied + ASSERT_EQ(Value(ret).toString(), "Hello world!"); + value_free(&ret); + + // 4 + ret = runReporter(code4); + ASSERT_TRUE(value_isPointer(&ret)); + ASSERT_EQ(value_toPointer(&ret), &pointee); + value_free(&ret); + + // 5 + ret = runReporter(code5); + ASSERT_TRUE(value_isPointer(&ret)); + ASSERT_EQ(value_toPointer(&ret), &pointee); + value_free(&ret); +} + +TEST_F(CodeBuilderTest, UnknownTypeReporter) +{ + Sprite sprite; + auto var = std::make_shared("", ""); + var->setValue("Hello world!"); + sprite.addVariable(var); + + ICodeBuilder *builder = m_utils.createReporterBuilder(&sprite); + + CompilerValue *num = builder->addConstValue(5.2); + builder->addFunctionCall("test_const_unknown", Compiler::StaticType::Unknown, { Compiler::StaticType::Unknown }, { num }); + + auto code = builder->build(); + + Script script(&sprite, nullptr, nullptr); + script.setCode(code); + Thread thread1(&sprite, nullptr, &script); + auto ctx = code->createExecutionContext(&thread1); + + ValueData ret = code->runReporter(ctx.get()); + ASSERT_TRUE(value_isNumber(&ret)); + ASSERT_EQ(value_toDouble(&ret), 5.2); + value_free(&ret); +} diff --git a/test/codegen/codegentestutils.cpp b/test/codegen/codegentestutils.cpp new file mode 100644 index 000000000..6311f5fb1 --- /dev/null +++ b/test/codegen/codegentestutils.cpp @@ -0,0 +1,375 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "codegentestutils.h" +#include "testfunctions.h" + +using namespace libscratchcpp; + +using ::testing::ReturnRef; + +CodeGenTestUtils::CodeGenTestUtils() +{ + test_function(nullptr, nullptr, nullptr, nullptr, nullptr); // force dependency + + EXPECT_CALL(m_engine, targets()).WillRepeatedly(ReturnRef(m_emptyTargets)); +} + +ICodeBuilder *CodeGenTestUtils::createBuilder(Target *target, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) +{ + if (m_contexts.find(target) == m_contexts.cend() || !target) + m_contexts[target] = CodeBuilderFactory::instance()->createCtx(&m_engine, target); + + m_contextList.push_back(m_contexts[target]); + m_builder = CodeBuilderFactory::instance()->create(m_contexts[target].get(), procedurePrototype, codeType); + + return m_builder.get(); +} + +ICodeBuilder *CodeGenTestUtils::createBuilder(Target *target, bool warp) +{ + m_procedurePrototype = std::make_shared("test"); + m_procedurePrototype->setWarp(warp); + createBuilder(target, m_procedurePrototype.get()); + + return m_builder.get(); +} + +ICodeBuilder *CodeGenTestUtils::createBuilder(bool warp) +{ + return createBuilder(nullptr, warp); +} + +ICodeBuilder *CodeGenTestUtils::createReporterBuilder(Target *target) +{ + return createBuilder(target, nullptr, Compiler::CodeType::Reporter); +} + +ICodeBuilder *CodeGenTestUtils::createPredicateBuilder(Target *target) +{ + return createBuilder(target, nullptr, Compiler::CodeType::HatPredicate); +} + +CompilerValue *CodeGenTestUtils::callConstFuncForType(ValueType type, CompilerValue *arg) +{ + switch (type) { + case ValueType::Number: + return m_builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { arg }); + + case ValueType::Bool: + return m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { arg }); + + case ValueType::String: + return m_builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { arg }); + + default: + EXPECT_TRUE(false); + return nullptr; + } +} + +CompilerValue *CodeGenTestUtils::callConstFuncForType(ValueType type, CompilerValue *arg, Compiler::StaticType returnType) +{ + switch (type) { + case ValueType::Number: + return m_builder->addFunctionCall("test_const_number_unknown", returnType, { Compiler::StaticType::Number }, { arg }); + + case ValueType::Bool: + return m_builder->addFunctionCall("test_const_bool_unknown", returnType, { Compiler::StaticType::Bool }, { arg }); + + case ValueType::String: + return m_builder->addFunctionCall("test_const_string_unknown", returnType, { Compiler::StaticType::String }, { arg }); + + default: + EXPECT_TRUE(false); + } + + return nullptr; +} + +Value CodeGenTestUtils::getOpResult(OpType type, bool rawArg, const Value &v) +{ + createReporterBuilder(nullptr); + + CompilerValue *arg = m_builder->addConstValue(v); + + if (rawArg) + addOp(type, arg); + else { + arg = callConstFuncForType(v.type(), arg); + addOp(type, arg); + } + + auto code = m_builder->build(); + Script script(&m_target, nullptr, nullptr); + script.setCode(code); + Thread thread(&m_target, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + + ValueData data = code->runReporter(ctx.get()); + Value ret(data); + value_free(&data); + + return ret; +} + +Value CodeGenTestUtils::getOpResult(OpType type, bool rawArgs, const Value &v1, const Value &v2) +{ + createReporterBuilder(nullptr); + + CompilerValue *arg1 = m_builder->addConstValue(v1); + CompilerValue *arg2 = m_builder->addConstValue(v2); + + if (rawArgs) + addOp(type, arg1, arg2); + else { + arg1 = callConstFuncForType(v1.type(), arg1); + arg2 = callConstFuncForType(v2.type(), arg2); + addOp(type, arg1, arg2); + } + + auto code = m_builder->build(); + Script script(&m_target, nullptr, nullptr); + script.setCode(code); + Thread thread(&m_target, nullptr, &script); + auto ctx = code->createExecutionContext(&thread); + ctx->setRng(&m_rng); + + ValueData data = code->runReporter(ctx.get()); + Value ret(data); + value_free(&data); + + return ret; +} + +Value CodeGenTestUtils::getExpectedOpResult(OpType type, const Value &v) +{ + switch (type) { + case OpType::Not: + return !v.toBool(); + + case OpType::StringLength: + return v.toUtf16().size(); + + default: + EXPECT_TRUE(false); + return Value(); + } +} + +Value CodeGenTestUtils::getExpectedOpResult(OpType type, const Value &v1, const Value &v2) +{ + switch (type) { + case OpType::Add: + return v1 + v2; + + case OpType::Sub: + return v1 - v2; + + case OpType::Mul: + return v1 * v2; + + case OpType::Div: + return v1 / v2; + + case OpType::Random: { + const double sum = v1.toDouble() + v2.toDouble(); + + if (std::isnan(sum) || std::isinf(sum)) + return sum; + + return v1.isInt() && v2.isInt() ? m_rng.randint(v1.toLong(), v2.toLong()) : m_rng.randintDouble(v1.toDouble(), v2.toDouble()); + } + + case OpType::RandomInt: + return m_rng.randint(v1.toLong(), v2.toLong()); + + case OpType::CmpEQ: + return v1 == v2; + + case OpType::CmpGT: + return v1 > v2; + + case OpType::CmpLT: + return v1 < v2; + + case OpType::StrCmpEQCS: { + StringPtr *s1 = string_pool_new(); + StringPtr *s2 = string_pool_new(); + value_toStringPtr(&v1.data(), s1); + value_toStringPtr(&v2.data(), s2); + + bool ret = string_compare_case_sensitive(s1, s2) == 0; + + string_pool_free(s1); + string_pool_free(s2); + return ret; + } + + case OpType::StrCmpEQCI: { + StringPtr *s1 = string_pool_new(); + StringPtr *s2 = string_pool_new(); + value_toStringPtr(&v1.data(), s1); + value_toStringPtr(&v2.data(), s2); + + bool ret = string_compare_case_insensitive(s1, s2) == 0; + + string_pool_free(s1); + string_pool_free(s2); + return ret; + } + + case OpType::And: + return v1.toBool() && v2.toBool(); + + case OpType::Or: + return v1.toBool() || v2.toBool(); + + case OpType::Mod: + return v1 % v2; + + default: + EXPECT_TRUE(false); + return Value(); + } +} + +EngineMock &CodeGenTestUtils::engine() +{ + return m_engine; +} + +TargetMock &CodeGenTestUtils::target() +{ + return m_target; +} + +const RandomGeneratorMock &CodeGenTestUtils::rng() const +{ + return m_rng; +} + +CompilerValue *CodeGenTestUtils::addOp(OpType type, CompilerValue *arg) +{ + switch (type) { + case OpType::Not: + return m_builder->createNot(arg); + + case OpType::Round: + return m_builder->createRound(arg); + + case OpType::Abs: + return m_builder->createAbs(arg); + + case OpType::Floor: + return m_builder->createFloor(arg); + + case OpType::Ceil: + return m_builder->createCeil(arg); + + case OpType::Sqrt: + return m_builder->createSqrt(arg); + + case OpType::Sin: + return m_builder->createSin(arg); + + case OpType::Cos: + return m_builder->createCos(arg); + + case OpType::Tan: + return m_builder->createTan(arg); + + case OpType::Asin: + return m_builder->createAsin(arg); + + case OpType::Acos: + return m_builder->createAcos(arg); + + case OpType::Atan: + return m_builder->createAtan(arg); + + case OpType::Ln: + return m_builder->createLn(arg); + + case OpType::Log10: + return m_builder->createLog10(arg); + + case OpType::Exp: + return m_builder->createExp(arg); + + case OpType::Exp10: + return m_builder->createExp10(arg); + + case OpType::StringLength: + return m_builder->addStringLength(arg); + + default: + EXPECT_TRUE(false); + return nullptr; + } +} + +CompilerValue *CodeGenTestUtils::addOp(OpType type, CompilerValue *arg1, CompilerValue *arg2) +{ + switch (type) { + case OpType::Add: + return m_builder->createAdd(arg1, arg2); + + case OpType::Sub: + return m_builder->createSub(arg1, arg2); + + case OpType::Mul: + return m_builder->createMul(arg1, arg2); + + case OpType::Div: + return m_builder->createDiv(arg1, arg2); + + case OpType::Random: + return m_builder->createRandom(arg1, arg2); + + case OpType::RandomInt: + return m_builder->createRandomInt(arg1, arg2); + + case OpType::CmpEQ: + return m_builder->createCmpEQ(arg1, arg2); + + case OpType::CmpGT: + return m_builder->createCmpGT(arg1, arg2); + + case OpType::CmpLT: + return m_builder->createCmpLT(arg1, arg2); + + case OpType::StrCmpEQCS: + return m_builder->createStrCmpEQ(arg1, arg2, true); + + case OpType::StrCmpEQCI: + return m_builder->createStrCmpEQ(arg1, arg2, false); + + case OpType::And: + return m_builder->createAnd(arg1, arg2); + + case OpType::Or: + return m_builder->createOr(arg1, arg2); + + case OpType::Mod: + return m_builder->createMod(arg1, arg2); + + case OpType::StringConcat: + return m_builder->createStringConcat(arg1, arg2); + + case OpType::StringChar: + return m_builder->addStringChar(arg1, arg2); + + default: + EXPECT_TRUE(false); + return nullptr; + } +} diff --git a/test/codegen/codegentestutils.h b/test/codegen/codegentestutils.h new file mode 100644 index 000000000..9fb9598a8 --- /dev/null +++ b/test/codegen/codegentestutils.h @@ -0,0 +1,109 @@ +#pragma once + +#include +#include +#include +#include + +#include + +#define ASSERT_NUM_OP1(utils, type, rawArg, v) \ + Value result = utils.getOpResult(type, rawArg, v); \ + Value expected = utils.getExpectedOpResult(type, v); \ + ASSERT_EQ(result.isNaN(), expected.isNaN()); \ + ASSERT_EQ(result.toDouble(), expected.toDouble()); + +#define ASSERT_NUM_OP2(utils, type, rawArgs, v1, v2) \ + Value result = utils.getOpResult(type, rawArgs, v1, v2); \ + Value expected = utils.getExpectedOpResult(type, v1, v2); \ + ASSERT_EQ(result.isNaN(), expected.isNaN()); \ + ASSERT_EQ(result.toDouble(), expected.toDouble()); + +#define ASSERT_BOOL_OP1(utils, type, rawArg, v) ASSERT_EQ(utils.getOpResult(type, rawArg, v).toBool(), m_utils.getExpectedOpResult(type, v).toBool()); +#define ASSERT_BOOL_OP2(utils, type, rawArgs, v1, v2) ASSERT_EQ(utils.getOpResult(type, rawArgs, v1, v2).toBool(), m_utils.getExpectedOpResult(type, v1, v2).toBool()); + +#define ASSERT_STRING_OP1(utils, type, rawArg, v) ASSERT_EQ(utils.getOpResult(type, rawArg, v).toString(), m_utils.getExpectedOpResult(type, v).toString()); +#define ASSERT_STRING_OP2(utils, type, rawArgs, v1, v2) ASSERT_EQ(utils.getOpResult(type, rawArgs, v1, v2).toString(), m_utils.getExpectedOpResult(type, v1, v2).toString()); + +namespace libscratchcpp +{ + +class CompilerContext; + +class CodeGenTestUtils +{ + public: + enum class OpType + { + Add, + Sub, + Mul, + Div, + Random, + RandomInt, + CmpEQ, + CmpGT, + CmpLT, + StrCmpEQCS, + StrCmpEQCI, + And, + Or, + Not, + Mod, + Round, + Abs, + Floor, + Ceil, + Sqrt, + Sin, + Cos, + Tan, + Asin, + Acos, + Atan, + Ln, + Log10, + Exp, + Exp10, + StringConcat, + StringChar, + StringLength + }; + + CodeGenTestUtils(); + + ICodeBuilder *createBuilder(Target *target, BlockPrototype *procedurePrototype, Compiler::CodeType codeType = Compiler::CodeType::Script); + ICodeBuilder *createBuilder(Target *target, bool warp); + ICodeBuilder *createBuilder(bool warp); + + ICodeBuilder *createReporterBuilder(Target *target); + ICodeBuilder *createPredicateBuilder(Target *target); + + CompilerValue *callConstFuncForType(ValueType type, CompilerValue *arg); + CompilerValue *callConstFuncForType(ValueType type, CompilerValue *arg, Compiler::StaticType returnType); + + Value getOpResult(OpType type, bool rawArg, const Value &v); + Value getOpResult(OpType type, bool rawArgs, const Value &v1, const Value &v2); + + Value getExpectedOpResult(OpType type, const Value &v); + Value getExpectedOpResult(OpType type, const Value &v1, const Value &v2); + + EngineMock &engine(); + TargetMock &target(); + const RandomGeneratorMock &rng() const; + + private: + CompilerValue *addOp(OpType type, CompilerValue *arg); + CompilerValue *addOp(OpType type, CompilerValue *arg1, CompilerValue *arg2); + + std::unordered_map> m_contexts; + std::vector> m_contextList; + std::shared_ptr m_builder; + std::shared_ptr m_procedurePrototype; + EngineMock m_engine; + TargetMock m_target; // NOTE: isStage() is used for call expectations + RandomGeneratorMock m_rng; + const std::vector> m_emptyTargets; +}; + +} // namespace libscratchcpp diff --git a/test/codegen/main.cpp b/test/codegen/main.cpp new file mode 100644 index 000000000..1898d06dd --- /dev/null +++ b/test/codegen/main.cpp @@ -0,0 +1 @@ +#include "../common.h" diff --git a/test/codegen/testfunctions.cpp b/test/codegen/testfunctions.cpp new file mode 100644 index 000000000..a81af148d --- /dev/null +++ b/test/codegen/testfunctions.cpp @@ -0,0 +1,228 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "testfunctions.h" +#include "testmock.h" + +using namespace libscratchcpp; + +static int counter = 0; + +extern "C" +{ + void test_function(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData) + { + if (mock) + mock->script(ctx, target, varData, listData); + } + + ValueData test_reporter(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData) + { + if (mock) + return mock->reporter(ctx, target, varData, listData); + + return ValueData(); + } + + bool test_predicate(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData) + { + if (mock) + return mock->predicate(ctx, target, varData, listData); + + return false; + } + + void test_print_function(ValueData *arg1, ValueData *arg2) + { + std::string s1, s2; + value_toString(arg1, &s1); + value_toString(arg2, &s2); + std::cout << s1 << " " << s2 << std::endl; + } + + void test_empty_function() + { + std::cout << "empty" << std::endl; + } + + void test_ctx_function(ExecutionContext *ctx, const StringPtr *arg) + { + std::cout << ctx << std::endl; + std::cout << utf8::utf16to8(std::u16string(arg->data)) << std::endl; + } + + void test_function_no_args(Target *target) + { + target->isStage(); + std::cout << "no_args" << std::endl; + } + + void test_function_no_args_ret(StringPtr *ret, Target *target) + { + target->isStage(); + std::cout << "no_args_ret" << std::endl; + Value v("no_args_output"); + value_toStringPtr(&v.data(), ret); + } + + void test_function_1_arg(Target *target, const StringPtr *arg1) + { + target->isStage(); + std::cout << "1_arg " << utf8::utf16to8(std::u16string(arg1->data)) << std::endl; + } + + void test_function_1_arg_ret(StringPtr *ret, Target *target, const StringPtr *arg1) + { + target->isStage(); + std::cout << "1_arg_ret " << utf8::utf16to8(std::u16string(arg1->data)) << std::endl; + Value v("1_arg_output"); + value_toStringPtr(&v.data(), ret); + } + + void test_function_3_args(Target *target, const StringPtr *arg1, const StringPtr *arg2, const StringPtr *arg3) + { + target->isStage(); + std::cout << "3_args " << utf8::utf16to8(std::u16string(arg1->data)) << " " << utf8::utf16to8(std::u16string(arg2->data)) << " " << utf8::utf16to8(std::u16string(arg3->data)) << std::endl; + } + + void test_function_3_args_ret(StringPtr *ret, Target *target, const StringPtr *arg1, const StringPtr *arg2, const StringPtr *arg3) + { + target->isStage(); + std::cout << "3_args " << utf8::utf16to8(std::u16string(arg1->data)) << " " << utf8::utf16to8(std::u16string(arg2->data)) << " " << utf8::utf16to8(std::u16string(arg3->data)) << std::endl; + Value v("3_args_output"); + value_toStringPtr(&v.data(), ret); + } + + const void *test_function_1_ptr_arg_ret(Target *target, const int *arg1) + { + target->isStage(); + std::cout << "1_arg_ret " << *arg1 << std::endl; + return target; + } + + bool test_equals(const StringPtr *a, const StringPtr *b) + { + return string_compare_case_sensitive(a, b) == 0; + } + + void test_unreachable() + { + std::cout << "error: unreachable reached" << std::endl; + exit(1); + } + + bool test_lower_than(double a, double b) + { + return a < b; + } + + double test_const_number(double v) + { + return v; + } + + bool test_const_bool(bool v) + { + return v; + } + + void test_const_string(StringPtr *ret, const StringPtr *v) + { + string_assign(ret, v); + } + + ValueData test_const_unknown(const ValueData *v) + { + ValueData ret; + value_init(&ret); + value_assign_copy(&ret, v); + return ret; + } + + const void *test_const_pointer(const void *v) + { + return v; + } + + ValueData test_const_number_unknown(double v) + { + ValueData ret; + value_init(&ret); + value_assign_double(&ret, v); + return ret; + } + + ValueData test_const_bool_unknown(bool v) + { + ValueData ret; + value_init(&ret); + value_assign_bool(&ret, v); + return ret; + } + + ValueData test_const_string_unknown(const StringPtr *v) + { + ValueData ret; + value_init(&ret); + value_assign_stringPtr(&ret, v); + return ret; + } + + bool test_not(bool arg) + { + return !arg; + } + + void test_reset_counter() + { + counter = 0; + } + + void test_increment_counter() + { + counter++; + } + + double test_get_counter() + { + return counter; + } + + void test_print_number(double v) + { + std::cout << v << std::endl; + } + + void test_print_bool(bool v) + { + std::cout << v << std::endl; + } + + void test_print_string(const StringPtr *v) + { + std::cout << utf8::utf16to8(std::u16string(v->data)) << std::endl; + } + + void test_print_pointer(const void *v) + { + std::cout << v << std::endl; + } + + void test_print_unknown(const ValueData *v) + { + std::string str; + value_toString(v, &str); + std::cout << str << std::endl; + } + + void test_print_first_local_variable(Target *target) + { + std::cout << target->variableAt(0)->value().toString() << std::endl; + } +} diff --git a/test/codegen/testfunctions.h b/test/codegen/testfunctions.h new file mode 100644 index 000000000..c56162f47 --- /dev/null +++ b/test/codegen/testfunctions.h @@ -0,0 +1,63 @@ +#pragma once + +#include + +namespace libscratchcpp +{ + +class TestMock; +class Target; +class ValueData; +class List; +class ExecutionContext; +struct StringPtr; + +extern "C" +{ + void test_function(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData); + ValueData test_reporter(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData); + bool test_predicate(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData); + void test_print_function(ValueData *arg1, ValueData *arg2); + + void test_empty_function(); + void test_ctx_function(ExecutionContext *ctx, const StringPtr *arg); + + void test_function_no_args(Target *target); + void test_function_no_args_ret(StringPtr *ret, Target *target); + void test_function_1_arg(Target *target, const StringPtr *arg1); + void test_function_1_arg_ret(StringPtr *ret, Target *target, const StringPtr *arg1); + void test_function_3_args(Target *target, const StringPtr *arg1, const StringPtr *arg2, const StringPtr *arg3); + void test_function_3_args_ret(StringPtr *ret, Target *target, const StringPtr *arg1, const StringPtr *arg2, const StringPtr *arg3); + + const void *test_function_1_ptr_arg_ret(Target *target, const int *arg1); + + bool test_equals(const StringPtr *a, const StringPtr *b); + bool test_lower_than(double a, double b); + bool test_not(bool arg); + + double test_const_number(double v); + bool test_const_bool(bool v); + void test_const_string(StringPtr *ret, const StringPtr *v); + ValueData test_const_unknown(const ValueData *v); + const void *test_const_pointer(const void *v); + + ValueData test_const_number_unknown(double v); + ValueData test_const_bool_unknown(bool v); + ValueData test_const_string_unknown(const StringPtr *v); + + void test_unreachable(); + + void test_reset_counter(); + void test_increment_counter(); + double test_get_counter(); + + void test_print_number(double v); + void test_print_bool(bool v); + void test_print_string(const StringPtr *v); + void test_print_pointer(const void *v); + void test_print_unknown(const ValueData *v); + + void test_print_first_local_variable(Target *target); +} + +} // namespace libscratchcpp diff --git a/test/codegen/testmock.h b/test/codegen/testmock.h new file mode 100644 index 000000000..bfed10eaa --- /dev/null +++ b/test/codegen/testmock.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +namespace libscratchcpp +{ + +class Target; +class List; + +class TestMock +{ + public: + MOCK_METHOD(void, script, (ExecutionContext * ctx, Target *, ValueData **, List **)); + MOCK_METHOD(ValueData, reporter, (ExecutionContext * ctx, Target *, ValueData **, List **)); + MOCK_METHOD(bool, predicate, (ExecutionContext * ctx, Target *, ValueData **, List **)); +}; + +} // namespace libscratchcpp From f9c8be7a3d21d357dce5598e2831ed4c0faa931f Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Sat, 17 Oct 2026 17:32:33 +0200 Subject: [PATCH 3/4] Remove LLVMCodeBuilder test suite --- test/llvm/CMakeLists.txt | 1 - test/llvm/llvmcodebuilder_test.cpp | 3940 ---------------------------- 2 files changed, 3941 deletions(-) delete mode 100644 test/llvm/llvmcodebuilder_test.cpp diff --git a/test/llvm/CMakeLists.txt b/test/llvm/CMakeLists.txt index 4a51365c3..62ea1edf7 100644 --- a/test/llvm/CMakeLists.txt +++ b/test/llvm/CMakeLists.txt @@ -20,7 +20,6 @@ add_executable( llvmtestutils.h llvmexecutioncontext_test.cpp llvmexecutablecode_test.cpp - llvmcodebuilder_test.cpp llvminstructionlist_test.cpp code_analyzer/variable_type_analysis.cpp code_analyzer/list_type_analysis.cpp diff --git a/test/llvm/llvmcodebuilder_test.cpp b/test/llvm/llvmcodebuilder_test.cpp deleted file mode 100644 index 976bf2d32..000000000 --- a/test/llvm/llvmcodebuilder_test.cpp +++ /dev/null @@ -1,3940 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "llvmtestutils.h" - -using namespace libscratchcpp; - -using ::testing::Return; -using ::testing::Eq; - -class LLVMCodeBuilderTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMCodeBuilderTest, FunctionCalls) -{ - static const std::vector warpList = { false, true }; - - for (bool warp : warpList) { - LLVMCodeBuilder *builder = m_utils.createBuilder(warp); - - builder->addFunctionCall("test_empty_function", Compiler::StaticType::Void, {}, {}); - - CompilerValue *v = builder->addConstValue("test"); - builder->addFunctionCallWithCtx("test_ctx_function", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - - v = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("1"); - v = builder->addTargetFunctionCall("test_function_1_arg_ret", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); - CompilerValue *v1 = builder->addConstValue("2"); - CompilerValue *v2 = builder->addConstValue("3"); - builder->addTargetFunctionCall("test_function_3_args", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, { v, v1, v2 }); - - v = builder->addConstValue("test"); - v1 = builder->addConstValue("4"); - v2 = builder->addConstValue("5"); - v = builder->addTargetFunctionCall( - "test_function_3_args_ret", - Compiler::StaticType::String, - { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, - { v, v1, v2 }); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(123); - v = builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { v }); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(true); - v = builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(321.5); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - v = builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { v }); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - v = builder->addConstValue("test"); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - v = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - v = builder->addConstValue(true); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - v = builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - std::stringstream s; - s << ctx.get(); - std::string ctxPtr = s.str(); - - const std::string expected = - "empty\n" + ctxPtr + - "\n" - "test\n" - "no_args\n" - "no_args_ret\n" - "1_arg no_args_output\n" - "1_arg_ret 1\n" - "3_args 1_arg_output 2 3\n" - "3_args test 4 5\n" - "1_arg 3_args_output\n" - "123\n" - "1\n" - "321.5\n" - "321.5\n" - "test\n" - "test\n" - "true\n" - "true\n"; - - EXPECT_CALL(m_utils.target(), isStage()).Times(7); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_TRUE(code->isFinished(ctx.get())); - } -} - -TEST_F(LLVMCodeBuilderTest, FunctionCallsWithPointers) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - int var = 12; - CompilerValue *v = builder->addConstValue(&var); - v = builder->addTargetFunctionCall("test_function_1_ptr_arg_ret", Compiler::StaticType::Pointer, { Compiler::StaticType::Pointer }, { v }); - - builder->addFunctionCall("test_print_pointer", Compiler::StaticType::Void, { Compiler::StaticType::Pointer }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - std::stringstream s; - s << &m_utils.target(); - std::string ptr = s.str(); - - const std::string expected = "1_arg_ret 12\n" + ptr + "\n"; - - EXPECT_CALL(m_utils.target(), isStage()); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, ConstCasting) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - CompilerValue *v = builder->addConstValue(5.2); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - v = builder->addConstValue("-24.156"); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(true); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(0); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("false"); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("123"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("hello world"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "5.2\n" - "-24.156\n" - "1\n" - "0\n" - "0\n" - "123\n" - "hello world\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ConstCasting_ToMixedTypes) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - CompilerValue *v = builder->addConstValue(true); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Number | Compiler::StaticType::Bool }, { v }); - v = builder->addConstValue(-24.156); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Number | Compiler::StaticType::Bool }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "true\n" - "-24.156\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, RawValueCasting) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Number -> number - CompilerValue *v = builder->addConstValue(5.2); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Number -> bool - v = builder->addConstValue(-24.156); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(0); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Number -> string - v = builder->addConstValue(59.8); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // Bool -> number - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Bool -> bool - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Bool -> string - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // String -> number - v = builder->addConstValue("5.2"); - v = m_utils.callConstFuncForType(ValueType::String, v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // String -> bool - v = builder->addConstValue("abc"); - v = m_utils.callConstFuncForType(ValueType::String, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("false"); - v = m_utils.callConstFuncForType(ValueType::String, v); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // String -> string - v = builder->addConstValue("hello world"); - v = m_utils.callConstFuncForType(ValueType::String, v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "5.2\n" - "1\n" - "0\n" - "59.8\n" - "1\n" - "0\n" - "1\n" - "0\n" - "true\n" - "false\n" - "5.2\n" - "1\n" - "0\n" - "hello world\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ValueCasting_FromNumberBool) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Number | Bool -> number - CompilerValue *v = builder->addConstValue(5.2); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Number | Bool -> bool - v = builder->addConstValue(-24.156); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(0); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Number | Bool -> string - v = builder->addConstValue(4.5); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Number | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "5.2\n" - "1\n" - "1\n" - "0\n" - "1\n" - "4.5\n" - "true\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ValueCasting_FromNumberString) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Number | String -> number - CompilerValue *v = builder->addConstValue(42.5); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("123.45"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("not_a_number"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Number | String -> bool - v = builder->addConstValue(0); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(-15.7); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("false"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("hello"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Number | String -> string - v = builder->addConstValue(4.5); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("world"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "42.5\n" - "123.45\n" - "0\n" - "0\n" - "1\n" - "0\n" - "1\n" - "4.5\n" - "world\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ValueCasting_FromBoolString) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Bool | String -> number - CompilerValue *v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("456.78"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("invalid"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Bool | String -> bool - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("false"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("anything"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Bool | String -> string - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("test_string"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Bool | Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "1\n" - "0\n" - "456.78\n" - "0\n" - "1\n" - "0\n" - "0\n" - "1\n" - "true\n" - "false\n" - "test_string\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ValueCasting_FromUnknown) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Unknown -> number - CompilerValue *v = builder->addConstValue(42.5); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("123.45"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("not_a_number"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Unknown -> bool - v = builder->addConstValue(0); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(-15.7); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("false"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("hello"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Unknown -> string - v = builder->addConstValue(4.5); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("world"); - v = m_utils.callConstFuncForType(ValueType::String, v, Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // Unknown -> unknown (passthrough) - v = builder->addConstValue(321.5); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - v = builder->addConstValue("test"); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - v = builder->addConstValue(true); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "42.5\n" - "123.45\n" - "1\n" - "0\n" - "0\n" - "1\n" - "1\n" - "0\n" - "1\n" - "4.5\n" - "false\n" - "world\n" - "321.5\n" - "test\n" - "true\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, LocalVariables) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerLocalVariable *var1 = builder->createLocalVariable(Compiler::StaticType::Number); - CompilerLocalVariable *var2 = builder->createLocalVariable(Compiler::StaticType::Number); - CompilerLocalVariable *var3 = builder->createLocalVariable(Compiler::StaticType::Bool); - CompilerLocalVariable *var4 = builder->createLocalVariable(Compiler::StaticType::Bool); - - CompilerValue *v = builder->addConstValue(5); - builder->createLocalVariableWrite(var1, v); - - v = builder->addConstValue(-23.5); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->createLocalVariableWrite(var2, v); - - v = builder->addConstValue(5.2); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->createLocalVariableWrite(var2, v); - - v = builder->addConstValue(false); - builder->createLocalVariableWrite(var3, v); - - v = builder->addConstValue(true); - builder->createLocalVariableWrite(var3, v); - - v = builder->addConstValue(false); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->createLocalVariableWrite(var4, v); - - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var1) }); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var2) }); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var3) }); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { builder->addLocalVariableValue(var4) }); - - static const std::string expected = - "5\n" - "5.2\n" - "true\n" - "false\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, WriteVariable) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar1 = std::make_shared("", ""); - auto globalVar2 = std::make_shared("", ""); - auto globalVar3 = std::make_shared("", ""); - stage.addVariable(globalVar1); - stage.addVariable(globalVar2); - stage.addVariable(globalVar3); - - auto localVar1 = std::make_shared("", ""); - auto localVar2 = std::make_shared("", ""); - auto localVar3 = std::make_shared("", ""); - auto localVar4 = std::make_shared("", ""); - sprite.addVariable(localVar1); - sprite.addVariable(localVar2); - sprite.addVariable(localVar3); - sprite.addVariable(localVar4); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(5); - builder->createVariableWrite(globalVar1.get(), v); - - v = builder->addConstValue(-23.5); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->createVariableWrite(globalVar2.get(), v); - - v = builder->addConstValue("test"); - builder->createVariableWrite(globalVar3.get(), v); - - v = builder->addConstValue("abc"); - builder->createVariableWrite(localVar1.get(), v); - - v = builder->addConstValue("hello world"); - v = m_utils.callConstFuncForType(ValueType::String, v); - builder->createVariableWrite(localVar1.get(), v); - - v = builder->addConstValue(false); - builder->createVariableWrite(localVar2.get(), v); - - v = builder->addConstValue(true); - v = m_utils.callConstFuncForType(ValueType::Bool, v); - builder->createVariableWrite(localVar3.get(), v); - - v = builder->addConstValue(45.23); - v = m_utils.callConstFuncForType(ValueType::Number, v, Compiler::StaticType::Number | Compiler::StaticType::String); - builder->createVariableWrite(localVar4.get(), v); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_EQ(globalVar1->value(), 5); - ASSERT_EQ(globalVar2->value(), -23.5); - ASSERT_EQ(globalVar3->value(), "test"); - ASSERT_EQ(localVar1->value(), "hello world"); - ASSERT_EQ(localVar2->value(), false); - ASSERT_EQ(localVar3->value(), true); - ASSERT_EQ(localVar4->value(), 45.23); -} - -TEST_F(LLVMCodeBuilderTest, Select) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - // Number - CompilerValue *v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue(5.8), builder->addConstValue(-17.42), Compiler::StaticType::Number); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue(5.8), builder->addConstValue(-17.42), Compiler::StaticType::Number); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Bool - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue(true), builder->addConstValue(false), Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue(true), builder->addConstValue(false), Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // String - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue("hello"), builder->addConstValue("world"), Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue("hello"), builder->addConstValue("world"), Compiler::StaticType::String); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // Different types - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue("543"), builder->addConstValue("true"), Compiler::StaticType::Number); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue("543"), builder->addConstValue("true"), Compiler::StaticType::Number); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue(1), builder->addConstValue("false"), Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue(1), builder->addConstValue("false"), Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - // Unknown types - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue("test"), builder->addConstValue(-456.2), Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(false); - v = builder->createSelect(v, builder->addConstValue("abc"), builder->addConstValue(true), Compiler::StaticType::Unknown); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(true); - v = builder->createSelect(v, builder->addConstValue("abc"), builder->addConstValue(true), Compiler::StaticType::String | Compiler::StaticType::Bool); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "5.8\n" - "-17.42\n" - "1\n" - "0\n" - "hello\n" - "world\n" - "543\n" - "0\n" - "1\n" - "0\n" - "test\n" - "true\n" - "abc\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ReadVariable) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar1 = std::make_shared("", "", 87); - auto globalVar2 = std::make_shared("", "", 6.4); - auto globalVar3 = std::make_shared("", "", "abc"); - stage.addVariable(globalVar1); - stage.addVariable(globalVar2); - stage.addVariable(globalVar3); - - auto localVar1 = std::make_shared("", "", false); - auto localVar2 = std::make_shared("", "", true); - auto localVar3 = std::make_shared("", "", "test"); - sprite.addVariable(localVar1); - sprite.addVariable(localVar2); - sprite.addVariable(localVar3); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addVariableValue(globalVar1.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(globalVar2.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(globalVar3.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar1.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar2.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar3.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected; - expected += globalVar1->value().toString() + '\n'; - expected += globalVar2->value().toString() + '\n'; - expected += globalVar3->value().toString() + '\n'; - expected += localVar1->value().toString() + '\n'; - expected += localVar2->value().toString() + '\n'; - expected += localVar3->value().toString() + '\n'; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, SyncVariablesBeforeCallingFunction) -{ - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - - auto var = std::make_shared("", ""); - sprite.addVariable(var); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue("abc"); - builder->createVariableWrite(var.get(), v); - - v = builder->addConstValue(123); - builder->createVariableWrite(var.get(), v); - - builder->addTargetFunctionCall("test_print_first_local_variable", Compiler::StaticType::Void, {}, {}); - - v = builder->addConstValue(456); - builder->createVariableWrite(var.get(), v); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - - ASSERT_EQ(testing::internal::GetCapturedStdout(), "123\n"); -} - -TEST_F(LLVMCodeBuilderTest, CastNonRawValueToUnknownType) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto var = std::make_shared("", "", 87); - stage.addVariable(var); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - // Unknown type - CompilerValue *v = builder->addVariableValue(var.get()); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - // Number - v = builder->addConstValue(23.5); - builder->createVariableWrite(var.get(), v); - v = builder->addVariableValue(var.get()); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - // String - v = builder->addConstValue("Hello world"); - builder->createVariableWrite(var.get(), v); - v = builder->addVariableValue(var.get()); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - // Bool - v = builder->addConstValue(true); - builder->createVariableWrite(var.get(), v); - v = builder->addVariableValue(var.get()); - builder->addFunctionCall("test_print_unknown", Compiler::StaticType::Void, { Compiler::StaticType::Unknown }, { v }); - - std::string expected; - expected += var->value().toString() + '\n'; - expected += "23.5\n"; - expected += "Hello world\n"; - expected += "true\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ClearList) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList1 = std::make_shared("", ""); - auto globalList2 = std::make_shared("", ""); - auto globalList3 = std::make_shared("", ""); - stage.addList(globalList1); - stage.addList(globalList2); - stage.addList(globalList3); - - auto localList1 = std::make_shared("", ""); - auto localList2 = std::make_shared("", ""); - auto localList3 = std::make_shared("", ""); - sprite.addList(localList1); - sprite.addList(localList2); - sprite.addList(localList3); - - globalList1->append(1); - globalList1->append(2); - globalList1->append(3); - strings[globalList1.get()] = globalList1->toString(); - - globalList2->append("Lorem"); - globalList2->append("ipsum"); - globalList2->append(-4.52); - strings[globalList2.get()] = globalList2->toString(); - - globalList3->append(true); - globalList3->append(false); - globalList3->append(true); - strings[globalList3.get()] = globalList3->toString(); - - localList1->append("dolor"); - localList1->append("sit"); - localList1->append("amet"); - strings[localList1.get()] = localList1->toString(); - - localList2->append(10); - localList2->append(9.8); - localList2->append(true); - strings[localList2.get()] = localList2->toString(); - - localList3->append("test"); - localList3->append(1.2); - localList3->append(false); - strings[localList3.get()] = localList3->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - builder->createListClear(globalList1.get()); - builder->createListClear(globalList3.get()); - builder->createListClear(localList1.get()); - builder->createListClear(localList2.get()); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_TRUE(globalList1->empty()); - ASSERT_EQ(globalList2->toString(), strings[globalList2.get()]); - ASSERT_TRUE(globalList3->empty()); - - ASSERT_TRUE(localList1->empty()); - ASSERT_TRUE(localList2->empty()); - ASSERT_EQ(localList3->toString(), strings[localList3.get()]); -} - -TEST_F(LLVMCodeBuilderTest, RemoveFromList) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - strings[localList.get()] = localList->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(1); - builder->createListRemove(globalList.get(), v); - - v = builder->addConstValue(-1); - builder->createListRemove(globalList.get(), v); - - v = builder->addConstValue(3); - builder->createListRemove(globalList.get(), v); - - v = builder->addConstValue(3); - builder->createListRemove(localList.get(), v); - - v = builder->addConstValue(-1); - builder->createListRemove(localList.get(), v); - - v = builder->addConstValue(4); - builder->createListRemove(localList.get(), v); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_EQ(globalList->toString(), "13"); - ASSERT_EQ(localList->toString(), "Lorem ipsum dolor"); -} - -TEST_F(LLVMCodeBuilderTest, AppendToList) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - strings[localList.get()] = localList->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(1); - builder->createListAppend(globalList.get(), v); - - v = builder->addConstValue("test"); - builder->createListAppend(globalList.get(), v); - - v = builder->addConstValue(3); - builder->createListAppend(localList.get(), v); - - builder->createListClear(localList.get()); - - v = builder->addConstValue(true); - builder->createListAppend(localList.get(), v); - - v = builder->addConstValue(false); - builder->createListAppend(localList.get(), v); - - v = builder->addConstValue("hello world"); - builder->createListAppend(localList.get(), v); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_EQ(globalList->toString(), "1 2 3 1 test"); - ASSERT_EQ(localList->toString(), "true false hello world"); -} - -TEST_F(LLVMCodeBuilderTest, InsertToList) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - strings[localList.get()] = localList->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v1 = builder->addConstValue(2); - CompilerValue *v2 = builder->addConstValue(1); - builder->createListInsert(globalList.get(), v1, v2); - - v1 = builder->addConstValue(3); - v2 = builder->addConstValue("test"); - builder->createListInsert(globalList.get(), v1, v2); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(3); - builder->createListInsert(localList.get(), v1, v2); - - builder->createListClear(localList.get()); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(true); - builder->createListInsert(localList.get(), v1, v2); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(false); - builder->createListInsert(localList.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue("hello world"); - builder->createListInsert(localList.get(), v1, v2); - - v1 = builder->addConstValue(3); - v2 = builder->addConstValue("test"); - builder->createListInsert(localList.get(), v1, v2); - - v1 = builder->addConstValue(-1); - v2 = builder->addConstValue(123); - builder->createListInsert(localList.get(), v1, v2); - - v1 = builder->addConstValue(6); - v2 = builder->addConstValue(123); - builder->createListInsert(localList.get(), v1, v2); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_EQ(globalList->toString(), "1 2 1 test 3"); - ASSERT_EQ(localList->toString(), "false hello world true test"); -} - -TEST_F(LLVMCodeBuilderTest, ListReplace) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - strings[localList.get()] = localList->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v1 = builder->addConstValue(2); - CompilerValue *v2 = builder->addConstValue(1); - builder->createListReplace(globalList.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue("test"); - builder->createListReplace(globalList.get(), v1, v2); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(3); - builder->createListReplace(localList.get(), v1, v2); - - v1 = builder->addConstValue(2); - v2 = builder->addConstValue(true); - builder->createListReplace(localList.get(), v1, v2); - - v1 = builder->addConstValue(3); - v2 = builder->addConstValue("hello world"); - builder->createListReplace(localList.get(), v1, v2); - - v1 = builder->addConstValue(-1); - v2 = builder->addConstValue(123); - builder->createListReplace(localList.get(), v1, v2); - - v1 = builder->addConstValue(5); - v2 = builder->addConstValue(123); - builder->createListReplace(localList.get(), v1, v2); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - - ASSERT_EQ(globalList->toString(), "1 test 1"); - ASSERT_EQ(localList->toString(), "3 ipsum true hello world"); -} - -TEST_F(LLVMCodeBuilderTest, GetListContents) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - std::unordered_map strings; - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - strings[localList.get()] = localList->toString(); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addListContents(globalList.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListContents(localList.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "123\n" - "Lorem ipsum dolor sit\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - ASSERT_EQ(globalList->toString(), "123"); - ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); -} - -TEST_F(LLVMCodeBuilderTest, GetListItem) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList1 = std::make_shared("", ""); - sprite.addList(localList1); - - auto localList2 = std::make_shared("", ""); - sprite.addList(localList2); - - auto localList3 = std::make_shared("", ""); - sprite.addList(localList3); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList1->append("Lorem"); - localList1->append("ipsum"); - localList1->append("dolor"); - localList1->append("sit"); - - localList2->append(-564.121); - localList2->append(4257.4); - - localList3->append(true); - localList3->append(false); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - // Global - CompilerValue *v = builder->addConstValue(2); - v = builder->addListItem(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - CompilerValue *v1 = builder->addConstValue(1); - CompilerValue *v2 = builder->addConstValue("test"); - builder->createListReplace(globalList.get(), v1, v2); - - v = builder->addConstValue(0); - v = builder->addListItem(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(-1); - v = builder->addListItem(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(3); - v = builder->addListItem(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // Local 1 - v = builder->addConstValue(0); - v = builder->addListItem(localList1.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(2); - v = builder->addListItem(localList1.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(3); - v = builder->addListItem(localList1.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(-1); - v = builder->addListItem(localList1.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(4); - v = builder->addListItem(localList1.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // Local 2 - v = builder->addConstValue(-1); - v = builder->addListItem(localList2.get(), v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(2); - v = builder->addListItem(localList2.get(), v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Local 3 - v = builder->addConstValue(-1); - v = builder->addListItem(localList3.get(), v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue(2); - v = builder->addListItem(localList3.get(), v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - // Establish number type - builder->createListClear(localList3.get()); - builder->createListAppend(localList3.get(), builder->addConstValue(1.5)); - - // Out-of-range index should still return empty string - v = builder->addConstValue(2); - v = builder->addListItem(localList3.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "3\n" - "1\n" - "\n" - "\n" - "Lorem\n" - "dolor\n" - "sit\n" - "\n" - "\n" - "0\n" - "0\n" - "0\n" - "0\n" - "\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - ASSERT_EQ(globalList->toString(), "1 test 3"); - ASSERT_EQ(localList1->toString(), "Lorem ipsum dolor sit"); - ASSERT_EQ(localList2->toString(), "-564.121 4257.4"); - ASSERT_EQ(localList3->toString(), "1.5"); -} - -TEST_F(LLVMCodeBuilderTest, GetListSize) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addListSize(globalList.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListSize(localList.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "3\n" - "4\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - ASSERT_EQ(globalList->toString(), "123"); - ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); -} - -TEST_F(LLVMCodeBuilderTest, GetListItemIndex) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(2); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(1); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(0); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - CompilerValue *v1 = builder->addConstValue(1); - CompilerValue *v2 = builder->addConstValue("test"); - builder->createListReplace(globalList.get(), v1, v2); - - v = builder->addConstValue(2); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(1); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("test"); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("abc"); - v = builder->addListItemIndex(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("doLor"); - v = builder->addListItemIndex(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(true); - v = builder->addListItemIndex(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("site"); - v = builder->addListItemIndex(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "1\n" - "0\n" - "-1\n" - "-1\n" - "0\n" - "1\n" - "-1\n" - "2\n" - "-1\n" - "-1\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - ASSERT_EQ(globalList->toString(), "1 test 3"); - ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); -} - -TEST_F(LLVMCodeBuilderTest, ListContainsItem) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - globalList->append(1); - globalList->append(2); - globalList->append(3); - - localList->append("Lorem"); - localList->append("ipsum"); - localList->append("dolor"); - localList->append("sit"); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(2); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(1); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(0); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - CompilerValue *v1 = builder->addConstValue(1); - CompilerValue *v2 = builder->addConstValue("test"); - builder->createListReplace(globalList.get(), v1, v2); - - v = builder->addConstValue(2); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(1); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("test"); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("abc"); - v = builder->addListContains(globalList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("doLor"); - v = builder->addListContains(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(true); - v = builder->addListContains(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue("site"); - v = builder->addListContains(localList.get(), v); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - static const std::string expected = - "true\n" - "true\n" - "false\n" - "false\n" - "true\n" - "true\n" - "false\n" - "true\n" - "false\n" - "false\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - ASSERT_EQ(globalList->toString(), "1 test 3"); - ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit"); -} - -TEST_F(LLVMCodeBuilderTest, Yield) -{ - LLVMCodeBuilder *builder; - - auto build = [this, &builder]() { - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - - CompilerValue *v = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->yield(); - - v = builder->addConstValue("1"); - v = builder->addTargetFunctionCall("test_function_1_arg_ret", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); - CompilerValue *v1 = builder->addConstValue("2"); - CompilerValue *v2 = builder->addConstValue(3); - builder->addTargetFunctionCall("test_function_3_args", Compiler::StaticType::Void, { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, { v, v1, v2 }); - - v = builder->addConstValue("test"); - v1 = builder->addConstValue("4"); - v2 = builder->addConstValue("5"); - v = builder->addTargetFunctionCall( - "test_function_3_args_ret", - Compiler::StaticType::String, - { Compiler::StaticType::String, Compiler::StaticType::String, Compiler::StaticType::String }, - { v, v1, v2 }); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - }; - - // Without warp - builder = m_utils.createBuilder(false); - build(); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected1 = - "no_args\n" - "no_args_ret\n" - "1_arg no_args_output\n"; - - EXPECT_CALL(m_utils.target(), isStage()).Times(3); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - static const std::string expected2 = - "1_arg_ret 1\n" - "3_args 1_arg_output 2 3\n" - "3_args test 4 5\n" - "1_arg 3_args_output\n"; - - EXPECT_CALL(m_utils.target(), isStage()).Times(4); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2); - ASSERT_TRUE(code->isFinished(ctx.get())); - - // Terminate unfinished coroutine - EXPECT_CALL(m_utils.target(), isStage()).Times(3); - testing::internal::CaptureStdout(); - code->reset(ctx.get()); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - code->kill(ctx.get()); - ASSERT_TRUE(code->isFinished(ctx.get())); - - // Reset unfinished coroutine - EXPECT_CALL(m_utils.target(), isStage()).Times(3); - testing::internal::CaptureStdout(); - code->reset(ctx.get()); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - code->reset(ctx.get()); - - EXPECT_CALL(m_utils.target(), isStage()).Times(3); - testing::internal::CaptureStdout(); - code->reset(ctx.get()); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); // leave unfinished coroutine - - // With warp - builder = m_utils.createBuilder(true); - build(); - code = builder->build(); - ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "no_args\n" - "no_args_ret\n" - "1_arg no_args_output\n" - "1_arg_ret 1\n" - "3_args 1_arg_output 2 3\n" - "3_args test 4 5\n" - "1_arg 3_args_output\n"; - - EXPECT_CALL(m_utils.target(), isStage()).Times(7); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, VariablesAfterSuspend) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar = std::make_shared("", "", 87); - stage.addVariable(globalVar); - - auto localVar = std::make_shared("", "", "test"); - sprite.addVariable(localVar); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, false); - - CompilerValue *v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(true); - builder->createVariableWrite(localVar.get(), v); - - builder->yield(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - } - builder->endLoop(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(0); - builder->createVariableWrite(localVar.get(), v); - - builder->beginLoopCondition(); - v = builder->createCmpLT(builder->addVariableValue(localVar.get()), builder->addConstValue(3)); - builder->beginWhileLoop(v); - builder->endLoop(); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(0); - builder->createVariableWrite(localVar.get(), v); - - builder->beginLoopCondition(); - v = builder->createCmpEQ(builder->addVariableValue(localVar.get()), builder->addConstValue(2)); - builder->beginRepeatUntilLoop(v); - builder->endLoop(); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "hello world\n" - "-4.8\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - ASSERT_FALSE(code->isFinished(ctx.get())); - - globalVar->setValue("hello world"); - localVar->setValue(-4.8); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_FALSE(code->isFinished(ctx.get())); - - globalVar->setValue("test"); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); - ASSERT_FALSE(code->isFinished(ctx.get())); - - globalVar->setValue(true); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "true\n"); - ASSERT_FALSE(code->isFinished(ctx.get())); - - localVar->setValue(1); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); - ASSERT_FALSE(code->isFinished(ctx.get())); - - localVar->setValue("2"); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); - ASSERT_FALSE(code->isFinished(ctx.get())); - - localVar->setValue(3); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "3\n"); - ASSERT_FALSE(code->isFinished(ctx.get())); - - localVar->setValue(1); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); - ASSERT_FALSE(code->isFinished(ctx.get())); - - localVar->setValue(2); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "2\n"); -} - -TEST_F(LLVMCodeBuilderTest, ListsAfterSuspend) -{ - - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList1 = std::make_shared("", ""); - stage.addList(globalList1); - - auto globalList2 = std::make_shared("", ""); - stage.addList(globalList2); - - auto localList1 = std::make_shared("", ""); - sprite.addList(localList1); - - auto localList2 = std::make_shared("", ""); - sprite.addList(localList2); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, false); - - builder->createListClear(globalList1.get()); - builder->createListClear(globalList2.get()); - builder->createListClear(localList1.get()); - builder->createListClear(localList2.get()); - - builder->createListAppend(globalList1.get(), builder->addConstValue(1)); - builder->createListAppend(globalList1.get(), builder->addConstValue(2)); - builder->createListAppend(globalList1.get(), builder->addConstValue(3)); - - builder->createListAppend(globalList2.get(), builder->addConstValue(1)); - builder->createListAppend(globalList2.get(), builder->addConstValue(2)); - builder->createListAppend(globalList2.get(), builder->addConstValue(3)); - - builder->createListReplace(globalList2.get(), builder->addConstValue(1), builder->addConstValue(12.5)); - - builder->createListInsert(localList1.get(), builder->addConstValue(0), builder->addConstValue("Lorem")); - builder->createListInsert(localList1.get(), builder->addConstValue(0), builder->addConstValue("ipsum")); - - builder->createListInsert(localList2.get(), builder->addConstValue(0), builder->addConstValue(true)); - builder->createListInsert(localList2.get(), builder->addConstValue(0), builder->addConstValue(false)); - - builder->yield(); - - CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(1)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(globalList1.get(), builder->addConstValue(2)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(globalList2.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(localList1.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(localList1.get(), builder->addConstValue(1)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(localList2.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "2\n" - "test\n" - "12.5\n" - "false\n" - "ipsum\n" - "-5.48\n" - "hello\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - ASSERT_FALSE(code->isFinished(ctx.get())); - - globalList1->replace(2, "test"); - globalList2->replace(0, false); - localList1->replace(1, -5.48); - localList2->replace(0, "hello"); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, IfStatement) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Without else branch (const condition) - CompilerValue *v = builder->addConstValue("true"); - builder->beginIfStatement(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endIf(); - - v = builder->addConstValue("false"); - builder->beginIfStatement(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endIf(); - - // Without else branch (condition returned by function) - CompilerValue *v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - CompilerValue *v2 = builder->addConstValue("no_args_output"); - v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); - builder->beginIfStatement(v); - v = builder->addConstValue(0); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - v2 = builder->addConstValue(""); - v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); - builder->beginIfStatement(v); - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - // With else branch (const condition) - v = builder->addConstValue("true"); - builder->beginIfStatement(v); - v = builder->addConstValue(2); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->beginElseBranch(); - v = builder->addConstValue(3); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - v = builder->addConstValue("false"); - builder->beginIfStatement(v); - v = builder->addConstValue(4); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->beginElseBranch(); - v = builder->addConstValue(5); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - // With else branch (condition returned by function) - v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - v2 = builder->addConstValue("no_args_output"); - v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); - builder->beginIfStatement(v); - v = builder->addConstValue(6); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->beginElseBranch(); - v = builder->addConstValue(7); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - v1 = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - v2 = builder->addConstValue(""); - v = builder->addFunctionCall("test_equals", Compiler::StaticType::Bool, { Compiler::StaticType::String, Compiler::StaticType::String }, { v1, v2 }); - builder->beginIfStatement(v); - v = builder->addConstValue(8); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->beginElseBranch(); - v = builder->addConstValue(9); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endIf(); - - // Nested 1 - CompilerValue *str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue(0); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->beginElseBranch(); - { - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - - v = builder->addConstValue(false); - builder->beginIfStatement(v); - builder->beginElseBranch(); - { - v = builder->addConstValue(2); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->endIf(); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - } - builder->endIf(); - } - builder->beginElseBranch(); - { - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(3); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->beginElseBranch(); - { - v = builder->addConstValue(4); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->endIf(); - } - builder->endIf(); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - - // Nested 2 - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue(5); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->beginElseBranch(); - { - v = builder->addConstValue(6); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->endIf(); - } - builder->beginElseBranch(); - { - str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); - - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(7); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->beginElseBranch(); - builder->endIf(); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - } - builder->endIf(); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "no_args\n" - "no_args_ret\n" - "1_arg 0\n" - "no_args_ret\n" - "1_arg 2\n" - "1_arg 5\n" - "no_args_ret\n" - "1_arg 6\n" - "no_args_ret\n" - "1_arg 9\n" - "1_arg 1\n" - "test\n" - "1_arg 2\n" - "test\n" - "test\n" - "1_arg 7\n" - "test\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, IfStatementVariables) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar = std::make_shared("", "", "test"); - stage.addVariable(globalVar); - - auto localVar = std::make_shared("", "", 87); - sprite.addVariable(localVar); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(true); - builder->createVariableWrite(localVar.get(), v); - - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue("hello world"); - builder->createVariableWrite(globalVar.get(), v); - } - builder->endIf(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue("hello world"); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(0); - builder->createVariableWrite(localVar.get(), v); - } - builder->endIf(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(true); - builder->createVariableWrite(globalVar.get(), v); - } - builder->endIf(); - - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue(-8.2); - builder->createVariableWrite(localVar.get(), v); - } - builder->endIf(); - } - builder->endIf(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "hello world\n" - "12.5\n" - "true\n" - "true\n" - "true\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, IfStatementLists) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList1 = std::make_shared("", ""); - stage.addList(globalList1); - - auto globalList2 = std::make_shared("", ""); - stage.addList(globalList2); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, false); - - auto resetLists = [this, builder, globalList1, globalList2, localList]() { - builder->createListClear(globalList1.get()); - builder->createListClear(globalList2.get()); - builder->createListClear(localList.get()); - - builder->createListAppend(globalList1.get(), builder->addConstValue(1)); - builder->createListAppend(globalList1.get(), builder->addConstValue(2)); - - builder->createListAppend(globalList2.get(), builder->addConstValue("hello")); - builder->createListAppend(globalList2.get(), builder->addConstValue("world")); - - builder->createListAppend(localList.get(), builder->addConstValue(false)); - builder->createListAppend(localList.get(), builder->addConstValue(true)); - }; - - auto checkLists = [this, builder, globalList1, globalList2, localList]() { - CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(localList.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - }; - - // if (true) - resetLists(); - - CompilerValue *v, *v1, *v2; - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endIf(); - - checkLists(); - - // if (false) - resetLists(); - - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endIf(); - - checkLists(); - - // if (true) { if (true) { ... }; if (false) { ... } } - resetLists(); - - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue(true); - builder->beginIfStatement(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - } - builder->endIf(); - - v = builder->addConstValue(false); - builder->beginIfStatement(v); - { - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endIf(); - } - builder->endIf(); - - checkLists(); - - std::string expected = - "1\n" - "hello\n" - "false\n" - "1\n" - "world\n" - "false\n" - "1\n" - "hello\n" - "false\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, RepeatLoop) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Const count - CompilerValue *v = builder->addConstValue("-5"); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - v = builder->addConstValue(0); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - v = builder->addConstValue(3); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - v = builder->addConstValue("2.4"); - builder->beginRepeatLoop(v); - v = builder->addConstValue(0); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endLoop(); - - v = builder->addConstValue("2.5"); - builder->beginRepeatLoop(v); - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->endLoop(); - - // Count returned by function - v = builder->addConstValue(2); - v = m_utils.callConstFuncForType(ValueType::Number, v); - builder->beginRepeatLoop(v); - CompilerValue *index = builder->addLoopIndex(); - builder->addTargetFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { index }); - builder->endLoop(); - - // Nested - CompilerValue *str = builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { builder->addConstValue("test") }); - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - } - builder->endLoop(); - - v = builder->addConstValue(2); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(3); - builder->beginRepeatLoop(v); - { - index = builder->addLoopIndex(); - builder->addTargetFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { index }); - } - builder->endLoop(); - } - builder->endLoop(); - - // str should still be allocated - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { str }); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "no_args\n" - "no_args\n" - "no_args\n" - "1_arg 0\n" - "1_arg 0\n" - "1_arg 1\n" - "1_arg 1\n" - "1_arg 1\n" - "0\n" - "1\n" - "1_arg 1\n" - "test\n" - "1_arg 1\n" - "test\n" - "1_arg 2\n" - "0\n" - "1\n" - "2\n" - "1_arg 1\n" - "test\n" - "1_arg 1\n" - "test\n" - "1_arg 2\n" - "0\n" - "1\n" - "2\n" - "test\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - // Yield - builder = m_utils.createBuilder(false); - - v = builder->addConstValue(3); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - code = builder->build(); - ctx = code->createExecutionContext(&thread); - - static const std::string expected1 = "no_args\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - - for (int i = 0; i < 3; i++) { - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - } - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_TRUE(testing::internal::GetCapturedStdout().empty()); - ASSERT_TRUE(code->isFinished(ctx.get())); - - // No warp no-op loop - builder = m_utils.createBuilder(false); - - v = builder->addConstValue(0); // don't yield - builder->beginRepeatLoop(v); - builder->endLoop(); - - code = builder->build(); - ctx = code->createExecutionContext(&thread); - code->run(ctx.get()); - ASSERT_TRUE(code->isFinished(ctx.get())); - - // Infinite no warp loop - builder = m_utils.createBuilder(false); - - v = builder->addConstValue("Infinity"); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - code = builder->build(); - ctx = code->createExecutionContext(&thread); - - for (int i = 0; i < 10; i++) { - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "no_args\n"); - ASSERT_FALSE(code->isFinished(ctx.get())); - } -} - -TEST_F(LLVMCodeBuilderTest, WhileLoop) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Const condition - builder->beginLoopCondition(); - CompilerValue *v = builder->addConstValue("false"); - builder->beginWhileLoop(v); - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - builder->beginLoopCondition(); - v = builder->addConstValue(false); - builder->beginWhileLoop(v); - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - // Condition returned by function - builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); - builder->beginLoopCondition(); - CompilerValue *v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - CompilerValue *v2 = builder->addConstValue(2); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - builder->beginWhileLoop(v); - v = builder->addConstValue(0); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - // Nested - builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); - builder->beginLoopCondition(); - v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - v2 = builder->addConstValue(3); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - builder->beginWhileLoop(v); - { - builder->beginLoopCondition(); - v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - v2 = builder->addConstValue(3); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - builder->beginWhileLoop(v); - { - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); - } - builder->endLoop(); - - v = builder->addConstValue(2); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->beginLoopCondition(); - v = builder->addConstValue(false); - builder->beginWhileLoop(v); - { - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - } - builder->endLoop(); - } - builder->endLoop(); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "1_arg 0\n" - "1_arg 0\n" - "1_arg 1\n" - "1_arg 1\n" - "1_arg 1\n" - "1_arg 2\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - // Yield - builder = m_utils.createBuilder(false); - - builder->beginLoopCondition(); - v = builder->addConstValue(true); - builder->beginWhileLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - code = builder->build(); - ctx = code->createExecutionContext(&thread); - - static const std::string expected1 = "no_args\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - - for (int i = 0; i < 10; i++) { - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - } -} - -TEST_F(LLVMCodeBuilderTest, RepeatUntilLoop) -{ - LLVMCodeBuilder *builder = m_utils.createBuilder(true); - - // Const condition - builder->beginLoopCondition(); - CompilerValue *v = builder->addConstValue("true"); - builder->beginRepeatUntilLoop(v); - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - builder->beginLoopCondition(); - v = builder->addConstValue(true); - builder->beginRepeatUntilLoop(v); - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - // Condition returned by function - builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); - builder->beginLoopCondition(); - CompilerValue *v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - CompilerValue *v2 = builder->addConstValue(2); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - builder->beginRepeatUntilLoop(v); - v = builder->addConstValue(0); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - // Nested - builder->addFunctionCall("test_reset_counter", Compiler::StaticType::Void, {}, {}); - builder->beginLoopCondition(); - v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - v2 = builder->addConstValue(3); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - builder->beginRepeatUntilLoop(v); - { - builder->beginLoopCondition(); - v1 = builder->addFunctionCall("test_get_counter", Compiler::StaticType::Number, {}, {}); - v2 = builder->addConstValue(3); - v = builder->addFunctionCall("test_lower_than", Compiler::StaticType::Bool, { Compiler::StaticType::Number, Compiler::StaticType::Number }, { v1, v2 }); - v = builder->addFunctionCall("test_not", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - builder->beginRepeatUntilLoop(v); - { - v = builder->addConstValue(1); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_increment_counter", Compiler::StaticType::Void, {}, {}); - } - builder->endLoop(); - - v = builder->addConstValue(2); - builder->addTargetFunctionCall("test_function_1_arg", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->beginLoopCondition(); - v = builder->addConstValue(true); - builder->beginRepeatUntilLoop(v); - { - builder->addFunctionCall("test_unreachable", Compiler::StaticType::Void, {}, {}); - } - builder->endLoop(); - } - builder->endLoop(); - - auto code = builder->build(); - Script script(&m_utils.target(), nullptr, nullptr); - script.setCode(code); - Thread thread(&m_utils.target(), nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - static const std::string expected = - "1_arg 0\n" - "1_arg 0\n" - "1_arg 1\n" - "1_arg 1\n" - "1_arg 1\n" - "1_arg 2\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - - // Yield - builder = m_utils.createBuilder(false); - - builder->beginLoopCondition(); - v = builder->addConstValue(false); - builder->beginRepeatUntilLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - code = builder->build(); - ctx = code->createExecutionContext(&thread); - - static const std::string expected1 = "no_args\n"; - - EXPECT_CALL(m_utils.target(), isStage).WillRepeatedly(Return(false)); - - for (int i = 0; i < 10; i++) { - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - } -} - -TEST_F(LLVMCodeBuilderTest, LoopVariables) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar = std::make_shared("", "", "test"); - stage.addVariable(globalVar); - - auto localVar = std::make_shared("", "", 87); - auto counter1 = std::make_shared("", ""); - auto counter2 = std::make_shared("", ""); - sprite.addVariable(localVar); - sprite.addVariable(counter1); - sprite.addVariable(counter2); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(true); - builder->createVariableWrite(localVar.get(), v); - - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createVariableWrite(globalVar.get(), v); - } - builder->endLoop(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(12.5); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(0); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createVariableWrite(globalVar.get(), v); - - v = builder->addConstValue(0); - builder->createVariableWrite(localVar.get(), v); - } - builder->endLoop(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addConstValue(0); - builder->createVariableWrite(counter1.get(), v); - - builder->beginLoopCondition(); - CompilerValue *v1 = builder->addVariableValue(counter1.get()); - CompilerValue *v2 = builder->addConstValue(5); - v = builder->createCmpLT(v1, v2); - builder->beginWhileLoop(v); - { - v = builder->addConstValue(0); - builder->createVariableWrite(counter2.get(), v); - - builder->beginLoopCondition(); - v1 = builder->addVariableValue(counter2.get()); - v2 = builder->addConstValue(3); - v = builder->createCmpEQ(v1, v2); - builder->beginRepeatUntilLoop(v); - { - v = builder->addConstValue(true); - builder->createVariableWrite(globalVar.get(), v); - - v1 = builder->addVariableValue(counter2.get()); - v2 = builder->addConstValue(1); - v = builder->createAdd(v1, v2); - builder->createVariableWrite(counter2.get(), v); - } - builder->endLoop(); - - builder->beginLoopCondition(); - v = builder->addConstValue(false); - builder->beginWhileLoop(v); - { - v = builder->addConstValue(-8.2); - builder->createVariableWrite(localVar.get(), v); - } - builder->endLoop(); - - v1 = builder->addVariableValue(counter1.get()); - v2 = builder->addConstValue(1); - v = builder->createAdd(v1, v2); - builder->createVariableWrite(counter1.get(), v); - } - builder->endLoop(); - - builder->beginLoopCondition(); - v = builder->addConstValue(true); - builder->beginRepeatUntilLoop(v); - { - v = builder->addConstValue(-8.2); - builder->createVariableWrite(localVar.get(), v); - } - builder->endLoop(); - - v = builder->addVariableValue(globalVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "hello world\n" - "12.5\n" - "true\n" - "true\n" - "true\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, VariableLoopTypeAnalysis) -{ - // This just makes sure the type analyzer is used correctly - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalVar = std::make_shared("", ""); - stage.addVariable(globalVar); - - auto localVar = std::make_shared("", ""); - sprite.addVariable(localVar); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(5.25); - builder->createVariableWrite(localVar.get(), v); - - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - // Type is unknown here because a string is assigned later - v = builder->addVariableValue(localVar.get()); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addConstValue("test"); - builder->createVariableWrite(localVar.get(), v); - } - builder->endLoop(); - - std::string expected = - "5.25\n" - "0\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, LoopLists) -{ - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList1 = std::make_shared("", ""); - stage.addList(globalList1); - - auto globalList2 = std::make_shared("", ""); - stage.addList(globalList2); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - auto counter1 = std::make_shared("", ""); - auto counter2 = std::make_shared("", ""); - sprite.addVariable(counter1); - sprite.addVariable(counter2); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - auto resetLists = [this, builder, globalList1, globalList2, localList]() { - builder->createListClear(globalList1.get()); - builder->createListClear(globalList2.get()); - builder->createListClear(localList.get()); - - builder->createListAppend(globalList1.get(), builder->addConstValue(1)); - builder->createListAppend(globalList1.get(), builder->addConstValue(2)); - - builder->createListAppend(globalList2.get(), builder->addConstValue("hello")); - builder->createListAppend(globalList2.get(), builder->addConstValue("world")); - - builder->createListAppend(localList.get(), builder->addConstValue(false)); - builder->createListAppend(localList.get(), builder->addConstValue(true)); - }; - - auto checkLists = [this, builder, globalList1, globalList2, localList]() { - CompilerValue *v = builder->addListItem(globalList1.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(globalList2.get(), builder->addConstValue(1)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(localList.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - }; - - // repeat (2) - resetLists(); - - CompilerValue *v, *v1, *v2; - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endLoop(); - - checkLists(); - - // repeat(0) - resetLists(); - - v = builder->addConstValue(0); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endLoop(); - - checkLists(); - - // while (counter1 < 5) { ... until (counter2 == 3) {... counter2++ }; while (false) { ... }; counter1++ } - resetLists(); - - v = builder->addConstValue(0); - builder->createVariableWrite(counter1.get(), v); - - builder->beginLoopCondition(); - v1 = builder->addVariableValue(counter1.get()); - v2 = builder->addConstValue(5); - v = builder->createCmpLT(v1, v2); - builder->beginWhileLoop(v); - { - v = builder->addConstValue(0); - builder->createVariableWrite(counter2.get(), v); - - builder->beginLoopCondition(); - v1 = builder->addVariableValue(counter2.get()); - v2 = builder->addConstValue(3); - v = builder->createCmpEQ(v1, v2); - builder->beginRepeatUntilLoop(v); - { - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - - v1 = builder->addVariableValue(counter2.get()); - v2 = builder->addConstValue(1); - v = builder->createAdd(v1, v2); - builder->createVariableWrite(counter2.get(), v); - } - builder->endLoop(); - - builder->beginLoopCondition(); - v = builder->addConstValue(false); - builder->beginWhileLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - } - builder->endLoop(); - - v1 = builder->addVariableValue(counter1.get()); - v2 = builder->addConstValue(1); - v = builder->createAdd(v1, v2); - builder->createVariableWrite(counter1.get(), v); - } - builder->endLoop(); - - checkLists(); - - // until (true) - resetLists(); - - builder->beginLoopCondition(); - v = builder->addConstValue(true); - builder->beginRepeatUntilLoop(v); - { - v = builder->addConstValue("hello world"); - builder->createListAppend(globalList1.get(), v); - - v1 = builder->addConstValue(0); - v2 = builder->addConstValue(8.5); - builder->createListInsert(globalList2.get(), v1, v2); - - v1 = builder->addConstValue(1); - v2 = builder->addConstValue(-4.25); - builder->createListReplace(localList.get(), v1, v2); - } - builder->endLoop(); - - checkLists(); - - std::string expected = - "1\n" - "8.5\n" - "false\n" - "1\n" - "world\n" - "false\n" - "1\n" - "8.5\n" - "false\n" - "1\n" - "world\n" - "false\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - ; - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, ListLoopTypeAnalysis) -{ - // This just makes sure the type analyzer is used correctly - Stage stage; - Sprite sprite; - sprite.setEngine(&m_utils.engine()); - EXPECT_CALL(m_utils.engine(), stage()).WillRepeatedly(Return(&stage)); - - auto globalList = std::make_shared("", ""); - stage.addList(globalList); - - auto localList = std::make_shared("", ""); - sprite.addList(localList); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - builder->createListClear(localList.get()); - - CompilerValue *v = builder->addConstValue(5.25); - builder->createListAppend(localList.get(), v); - - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - // Type is unknown here because a string is added later - v = builder->createSub(builder->addListSize(localList.get()), builder->addConstValue(1)); - v = builder->addListItem(localList.get(), v); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addListItemIndex(localList.get(), builder->addConstValue(5.25)); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addListContains(localList.get(), builder->addConstValue(5.25)); - builder->addFunctionCall("test_print_bool", Compiler::StaticType::Void, { Compiler::StaticType::Bool }, { v }); - - v = builder->addConstValue("test"); - builder->createListAppend(localList.get(), v); - } - builder->endLoop(); - - std::string expected = - "5.25\n" - "0\n" - "1\n" - "0\n" - "0\n" - "1\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, StopNoWarp) -{ - Sprite sprite; - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, false); - - builder->beginLoopCondition(); - CompilerValue *v = builder->addConstValue(true); - builder->beginWhileLoop(v); - builder->createStop(); - builder->endLoop(); - - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - - std::string expected = ""; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, StopWarp) -{ - Sprite sprite; - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *v = builder->addConstValue(true); - builder->beginIfStatement(v); - builder->createStop(); - builder->endIf(); - - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - - std::string expected = ""; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, StopAndReturn) -{ - Sprite sprite; - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->createStop(); - - std::string expected = "no_args\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, MultipleScripts) -{ - Sprite sprite; - - // Script 1 - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, nullptr); - - CompilerValue *v = builder->addConstValue("script1"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code1 = builder->build(); - - // Script 2 - builder = m_utils.createBuilder(&sprite, nullptr); - - v = builder->addConstValue("script2"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code2 = builder->build(); - - Script script1(&sprite, nullptr, nullptr); - script1.setCode(code1); - Thread thread1(&sprite, nullptr, &script1); - auto ctx = code1->createExecutionContext(&thread1); - - testing::internal::CaptureStdout(); - code1->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "script1\n"); - - Script script2(&sprite, nullptr, nullptr); - script2.setCode(code2); - Thread thread2(&sprite, nullptr, &script2); - ctx = code2->createExecutionContext(&thread2); - - testing::internal::CaptureStdout(); - code2->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), "script2\n"); -} - -TEST_F(LLVMCodeBuilderTest, Procedures) -{ - Sprite sprite; - auto var = std::make_shared("", ""); - auto list = std::make_shared("", ""); - sprite.addVariable(var); - sprite.addList(list); - - // Procedure 1 - BlockPrototype prototype1; - prototype1.setProcCode("procedure 1 %s %s %b"); - prototype1.setArgumentNames({ "any type 1", "any type 2", "bool" }); - prototype1.setArgumentIds({ "a", "b", "c" }); - prototype1.setWarp(false); - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype1); - - CompilerValue *v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - builder->addTargetFunctionCall("test_function_no_args", Compiler::StaticType::Void, {}, {}); - builder->endLoop(); - - builder->createVariableWrite(var.get(), builder->addProcedureArgument("any type 1")); - builder->createListClear(list.get()); - builder->createListAppend(list.get(), builder->addProcedureArgument("any type 2")); - - v = builder->addVariableValue(var.get()); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addListItem(list.get(), builder->addConstValue(0)); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - v = builder->addProcedureArgument("bool"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number }, { v }); - - v = builder->addProcedureArgument("invalid"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc1 = builder->build(); - - // Procedure 2 - BlockPrototype prototype2; - prototype2.setProcCode("procedure 2"); - prototype2.setWarp(true); - builder = m_utils.createBuilder(&sprite, &prototype2); - - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - builder->createProcedureCall(&prototype1, { builder->addConstValue(-652.3), builder->addConstValue(false), builder->addConstValue(true) }); - builder->endLoop(); - - auto proc2 = builder->build(); - - // Script - builder = m_utils.createBuilder(&sprite, false); - builder->createProcedureCall(&prototype1, { builder->addConstValue("test"), builder->addConstValue(true), builder->addConstValue(false) }); - builder->createProcedureCall(&prototype2, {}); - - v = builder->addProcedureArgument("test"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected1 = "no_args\n"; - - std::string expected2 = - "test\n" - "true\n" - "false\n" - "0\n" - "0\n"; - - std::string expected3 = - "no_args\n" - "no_args\n" - "-652.3\n" - "false\n" - "true\n" - "1\n" - "0\n" - "no_args\n" - "no_args\n" - "-652.3\n" - "false\n" - "true\n" - "1\n" - "0\n" - "0\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2 + expected3); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, UndefinedProcedure) -{ - Sprite sprite; - - BlockPrototype prototype; - prototype.setProcCode("procedure 1 %s %s %b"); - prototype.setArgumentNames({ "any type 1", "any type 2", "bool" }); - prototype.setArgumentIds({ "a", "b", "c" }); - prototype.setWarp(false); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, false); - builder->createProcedureCall(&prototype, { builder->addConstValue("test"), builder->addConstValue(true), builder->addConstValue(false) }); - - CompilerValue *v = builder->addConstValue("test"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = "test\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, ProcedureThreadStop_Warp) -{ - Sprite sprite; - - // Inner procedure (proc2): prints "inner_before", then stops the thread - BlockPrototype prototype2; - prototype2.setProcCode("proc2"); - prototype2.setWarp(true); - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); - - CompilerValue *v = builder->addConstValue("inner_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createThreadStop(); - - // This should NOT execute - v = builder->addConstValue("inner_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc2Code = builder->build(); - - // Outer procedure (proc1): prints "outer_before", calls proc2, then prints "outer_after" - BlockPrototype prototype1; - prototype1.setProcCode("proc1"); - prototype1.setWarp(true); - builder = m_utils.createBuilder(&sprite, &prototype1); - - v = builder->addConstValue("outer_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createProcedureCall(&prototype2, {}); - - // This should NOT execute (thread was stopped by proc2) - v = builder->addConstValue("outer_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc1Code = builder->build(); - - // Root script: prints "script_before", calls proc1, then prints "script_after" - builder = m_utils.createBuilder(&sprite, true); - - v = builder->addConstValue("script_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createProcedureCall(&prototype1, {}); - - // This should NOT execute (thread was stopped by proc2 via proc1) - v = builder->addConstValue("script_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "script_before\n" - "outer_before\n" - "inner_before\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, ProcedureThreadStop_NonWarp) -{ - Sprite sprite; - - // Inner procedure (proc2): prints "inner_before", then stops the thread - BlockPrototype prototype2; - prototype2.setProcCode("proc2"); - prototype2.setWarp(false); - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); - - CompilerValue *v = builder->addConstValue("inner_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createThreadStop(); - - // This should NOT execute - v = builder->addConstValue("inner_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc2Code = builder->build(); - - // Outer procedure (proc1): prints "outer_before", calls proc2, then prints "outer_after" - BlockPrototype prototype1; - prototype1.setProcCode("proc1"); - prototype1.setWarp(false); - builder = m_utils.createBuilder(&sprite, &prototype1); - - v = builder->addConstValue("outer_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createProcedureCall(&prototype2, {}); - - // This should NOT execute (thread was stopped by proc2) - v = builder->addConstValue("outer_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc1Code = builder->build(); - - // Root script: prints "script_before", calls proc1, then prints "script_after" - builder = m_utils.createBuilder(&sprite, false); - - v = builder->addConstValue("script_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - builder->createProcedureCall(&prototype1, {}); - - // This should NOT execute (thread was stopped by proc2 via proc1) - v = builder->addConstValue("script_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - std::string expected = - "script_before\n" - "outer_before\n" - "inner_before\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, ProcedureThreadStop_NonWarp_AfterYield) -{ - Sprite sprite; - - // Inner procedure (proc2): yields via a repeat loop, then stops the thread - // This exercises the coroutine resume path where the sentinel must propagate - BlockPrototype prototype2; - prototype2.setProcCode("proc2"); - prototype2.setWarp(false); - - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, &prototype2); - CompilerValue *v = builder->addConstValue("inner_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - // This repeat loop causes the coroutine to suspend (yield) on each iteration - v = builder->addConstValue(2); - builder->beginRepeatLoop(v); - { - v = builder->addConstValue("inner_loop"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - } - builder->endLoop(); - - // After the loop completes, stop the thread - builder->createThreadStop(); - - // This should NOT execute - v = builder->addConstValue("inner_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto proc2Code = builder->build(); - - // Outer procedure (proc1): calls proc2 - BlockPrototype prototype1; - prototype1.setProcCode("proc1"); - prototype1.setWarp(false); - - builder = m_utils.createBuilder(&sprite, &prototype1); - - v = builder->addConstValue("outer_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->createProcedureCall(&prototype2, {}); - - // This should NOT execute (thread was stopped by proc2) - v = builder->addConstValue("outer_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - auto proc1Code = builder->build(); - - // Root script: calls proc1 - builder = m_utils.createBuilder(&sprite, false); - v = builder->addConstValue("script_before"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - builder->createProcedureCall(&prototype1, {}); - - // This should NOT execute (thread was stopped by proc2 via proc1) - v = builder->addConstValue("script_after"); - builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String }, { v }); - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - // First run: enters the repeat loop in proc2, yields after first iteration - std::string expected1 = - "script_before\n" - "outer_before\n" - "inner_before\n" - "inner_loop\n"; - - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected1); - ASSERT_FALSE(code->isFinished(ctx.get())); - - // Second run: second iteration of the repeat loop, yields again - std::string expected2 = "inner_loop\n"; - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2); - ASSERT_FALSE(code->isFinished(ctx.get())); - - // Third run: loop is done, createThreadStop() fires, sentinel must propagate - // through the coroutine resume path back to the caller - // Neither "inner_after", "outer_after", nor "script_after" should print - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), ""); - ASSERT_TRUE(code->isFinished(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, Print) -{ - Sprite sprite; - LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true); - - CompilerValue *ret = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {}); - builder->createPrint(ret); - builder->createPrint(builder->addConstValue("\n")); - - std::string expected = "no_args_ret\nno_args_output\n"; - - auto code = builder->build(); - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - testing::internal::CaptureStdout(); - code->run(ctx.get()); - ASSERT_EQ(testing::internal::GetCapturedStdout(), expected); -} - -TEST_F(LLVMCodeBuilderTest, HatPredicates) -{ - Sprite sprite; - - // Predicate 1 - LLVMCodeBuilder *builder = m_utils.createPredicateBuilder(&sprite); - - builder->addConstValue(true); - - auto code1 = builder->build(); - - // Predicate 2 - builder = m_utils.createPredicateBuilder(&sprite); - - CompilerValue *v = builder->addConstValue(false); - builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v }); - - auto code2 = builder->build(); - - Script script1(&sprite, nullptr, nullptr); - script1.setCode(code1); - Thread thread1(&sprite, nullptr, &script1); - auto ctx = code1->createExecutionContext(&thread1); - - ASSERT_TRUE(code1->runPredicate(ctx.get())); - - Script script2(&sprite, nullptr, nullptr); - script2.setCode(code2); - Thread thread2(&sprite, nullptr, &script2); - ctx = code2->createExecutionContext(&thread2); - - ASSERT_FALSE(code2->runPredicate(ctx.get())); -} - -TEST_F(LLVMCodeBuilderTest, Reporters) -{ - Sprite sprite; - auto var = std::make_shared("", ""); - var->setValue("Hello world!"); - sprite.addVariable(var); - - // Reporter 1 - LLVMCodeBuilder *builder = m_utils.createReporterBuilder(&sprite); - - builder->addConstValue(-45.23); - - auto code1 = builder->build(); - - // Reporter 2 - builder = m_utils.createReporterBuilder(&sprite); - - CompilerValue *v = builder->addConstValue("test"); - builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { v }); - - auto code2 = builder->build(); - - // Reporter 3 - builder = m_utils.createReporterBuilder(&sprite); - builder->addVariableValue(var.get()); - - auto code3 = builder->build(); - - // Reporter 4 - builder = m_utils.createReporterBuilder(&sprite); - int pointee; - builder->addConstValue(&pointee); - - auto code4 = builder->build(); - - // Reporter 5 - builder = m_utils.createReporterBuilder(&sprite); - v = builder->addConstValue(&pointee); - builder->addFunctionCall("test_const_pointer", Compiler::StaticType::Pointer, { Compiler::StaticType::Pointer }, { v }); - - auto code5 = builder->build(); - - auto runReporter = [&sprite](std::shared_ptr code) { - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread1(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread1); - return code->runReporter(ctx.get()); - }; - - // 1 - ValueData ret = runReporter(code1); - ASSERT_TRUE(value_isNumber(&ret)); - ASSERT_EQ(value_toDouble(&ret), -45.23); - value_free(&ret); - - // 2 - ret = runReporter(code2); - ASSERT_EQ(Value(ret).toString(), "test"); - value_free(&ret); - - // 3 - ret = runReporter(code3); - var->setValue("abc"); // the string should be copied - ASSERT_EQ(Value(ret).toString(), "Hello world!"); - value_free(&ret); - - // 4 - ret = runReporter(code4); - ASSERT_TRUE(value_isPointer(&ret)); - ASSERT_EQ(value_toPointer(&ret), &pointee); - value_free(&ret); - - // 5 - ret = runReporter(code5); - ASSERT_TRUE(value_isPointer(&ret)); - ASSERT_EQ(value_toPointer(&ret), &pointee); - value_free(&ret); -} - -TEST_F(LLVMCodeBuilderTest, UnknownTypeReporter) -{ - Sprite sprite; - auto var = std::make_shared("", ""); - var->setValue("Hello world!"); - sprite.addVariable(var); - - LLVMCodeBuilder *builder = m_utils.createReporterBuilder(&sprite); - - CompilerValue *num = builder->addConstValue(5.2); - builder->addFunctionCall("test_const_unknown", Compiler::StaticType::Unknown, { Compiler::StaticType::Unknown }, { num }); - - auto code = builder->build(); - - Script script(&sprite, nullptr, nullptr); - script.setCode(code); - Thread thread1(&sprite, nullptr, &script); - auto ctx = code->createExecutionContext(&thread1); - - ValueData ret = code->runReporter(ctx.get()); - ASSERT_TRUE(value_isNumber(&ret)); - ASSERT_EQ(value_toDouble(&ret), 5.2); - value_free(&ret); -} From 8e519d1ca06210aeec9e3dc4c1e3e2784c1dfd68 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Sat, 17 Oct 2026 18:24:43 +0200 Subject: [PATCH 4/4] Move operator tests to codegen --- test/codegen/CMakeLists.txt | 33 + .../operators/equal_comparison_test.cpp | 1205 +++++++++++++++ test/codegen/operators/greater_than_test.cpp | 1340 +++++++++++++++++ test/codegen/operators/less_than_test.cpp | 1340 +++++++++++++++++ test/codegen/operators/logic/and_test.cpp | 890 +++++++++++ test/codegen/operators/logic/not_test.cpp | 260 ++++ test/codegen/operators/logic/or_test.cpp | 890 +++++++++++ test/codegen/operators/math/abs_test.cpp | 116 ++ test/codegen/operators/math/acos_test.cpp | 126 ++ test/codegen/operators/math/add_test.cpp | 130 ++ test/codegen/operators/math/asin_test.cpp | 126 ++ test/codegen/operators/math/atan_test.cpp | 86 ++ test/codegen/operators/math/ceil_test.cpp | 176 +++ test/codegen/operators/math/cos_test.cpp | 136 ++ test/codegen/operators/math/divide_test.cpp | 270 ++++ test/codegen/operators/math/exp10_test.cpp | 106 ++ test/codegen/operators/math/exp_test.cpp | 96 ++ test/codegen/operators/math/floor_test.cpp | 166 ++ test/codegen/operators/math/ln_test.cpp | 122 ++ test/codegen/operators/math/log10_test.cpp | 112 ++ test/codegen/operators/math/mod_test.cpp | 300 ++++ test/codegen/operators/math/multiply_test.cpp | 180 +++ .../operators/math/random_int_test.cpp | 134 ++ test/codegen/operators/math/random_test.cpp | 444 ++++++ test/codegen/operators/math/round_test.cpp | 156 ++ test/codegen/operators/math/sin_test.cpp | 136 ++ test/codegen/operators/math/sqrt_test.cpp | 96 ++ test/codegen/operators/math/subtract_test.cpp | 130 ++ test/codegen/operators/math/tan_test.cpp | 188 +++ .../operators/string/string_char_test.cpp | 80 + .../operators/string/string_concat_test.cpp | 40 + .../string_equal_case_insensitive_test.cpp | 1210 +++++++++++++++ .../string_equal_case_sensitive_test.cpp | 1210 +++++++++++++++ .../operators/string/string_length_test.cpp | 50 + test/llvm/CMakeLists.txt | 35 - test/llvm/llvmtestutils.cpp | 375 ----- test/llvm/llvmtestutils.h | 108 -- test/llvm/operators/equal_comparison_test.cpp | 1205 --------------- test/llvm/operators/greater_than_test.cpp | 1340 ----------------- test/llvm/operators/less_than_test.cpp | 1340 ----------------- test/llvm/operators/logic/and_test.cpp | 890 ----------- test/llvm/operators/logic/not_test.cpp | 260 ---- test/llvm/operators/logic/or_test.cpp | 890 ----------- test/llvm/operators/math/abs_test.cpp | 116 -- test/llvm/operators/math/acos_test.cpp | 126 -- test/llvm/operators/math/add_test.cpp | 130 -- test/llvm/operators/math/asin_test.cpp | 126 -- test/llvm/operators/math/atan_test.cpp | 86 -- test/llvm/operators/math/ceil_test.cpp | 176 --- test/llvm/operators/math/cos_test.cpp | 136 -- test/llvm/operators/math/divide_test.cpp | 270 ---- test/llvm/operators/math/exp10_test.cpp | 106 -- test/llvm/operators/math/exp_test.cpp | 96 -- test/llvm/operators/math/floor_test.cpp | 166 -- test/llvm/operators/math/ln_test.cpp | 122 -- test/llvm/operators/math/log10_test.cpp | 112 -- test/llvm/operators/math/mod_test.cpp | 300 ---- test/llvm/operators/math/multiply_test.cpp | 180 --- test/llvm/operators/math/random_int_test.cpp | 134 -- test/llvm/operators/math/random_test.cpp | 444 ------ test/llvm/operators/math/round_test.cpp | 156 -- test/llvm/operators/math/sin_test.cpp | 136 -- test/llvm/operators/math/sqrt_test.cpp | 96 -- test/llvm/operators/math/subtract_test.cpp | 130 -- test/llvm/operators/math/tan_test.cpp | 188 --- .../operators/string/string_char_test.cpp | 80 - .../operators/string/string_concat_test.cpp | 40 - .../string_equal_case_insensitive_test.cpp | 1210 --------------- .../string_equal_case_sensitive_test.cpp | 1210 --------------- .../operators/string/string_length_test.cpp | 50 - 70 files changed, 12080 insertions(+), 12565 deletions(-) create mode 100644 test/codegen/operators/equal_comparison_test.cpp create mode 100644 test/codegen/operators/greater_than_test.cpp create mode 100644 test/codegen/operators/less_than_test.cpp create mode 100644 test/codegen/operators/logic/and_test.cpp create mode 100644 test/codegen/operators/logic/not_test.cpp create mode 100644 test/codegen/operators/logic/or_test.cpp create mode 100644 test/codegen/operators/math/abs_test.cpp create mode 100644 test/codegen/operators/math/acos_test.cpp create mode 100644 test/codegen/operators/math/add_test.cpp create mode 100644 test/codegen/operators/math/asin_test.cpp create mode 100644 test/codegen/operators/math/atan_test.cpp create mode 100644 test/codegen/operators/math/ceil_test.cpp create mode 100644 test/codegen/operators/math/cos_test.cpp create mode 100644 test/codegen/operators/math/divide_test.cpp create mode 100644 test/codegen/operators/math/exp10_test.cpp create mode 100644 test/codegen/operators/math/exp_test.cpp create mode 100644 test/codegen/operators/math/floor_test.cpp create mode 100644 test/codegen/operators/math/ln_test.cpp create mode 100644 test/codegen/operators/math/log10_test.cpp create mode 100644 test/codegen/operators/math/mod_test.cpp create mode 100644 test/codegen/operators/math/multiply_test.cpp create mode 100644 test/codegen/operators/math/random_int_test.cpp create mode 100644 test/codegen/operators/math/random_test.cpp create mode 100644 test/codegen/operators/math/round_test.cpp create mode 100644 test/codegen/operators/math/sin_test.cpp create mode 100644 test/codegen/operators/math/sqrt_test.cpp create mode 100644 test/codegen/operators/math/subtract_test.cpp create mode 100644 test/codegen/operators/math/tan_test.cpp create mode 100644 test/codegen/operators/string/string_char_test.cpp create mode 100644 test/codegen/operators/string/string_concat_test.cpp create mode 100644 test/codegen/operators/string/string_equal_case_insensitive_test.cpp create mode 100644 test/codegen/operators/string/string_equal_case_sensitive_test.cpp create mode 100644 test/codegen/operators/string/string_length_test.cpp delete mode 100644 test/llvm/llvmtestutils.cpp delete mode 100644 test/llvm/llvmtestutils.h delete mode 100644 test/llvm/operators/equal_comparison_test.cpp delete mode 100644 test/llvm/operators/greater_than_test.cpp delete mode 100644 test/llvm/operators/less_than_test.cpp delete mode 100644 test/llvm/operators/logic/and_test.cpp delete mode 100644 test/llvm/operators/logic/not_test.cpp delete mode 100644 test/llvm/operators/logic/or_test.cpp delete mode 100644 test/llvm/operators/math/abs_test.cpp delete mode 100644 test/llvm/operators/math/acos_test.cpp delete mode 100644 test/llvm/operators/math/add_test.cpp delete mode 100644 test/llvm/operators/math/asin_test.cpp delete mode 100644 test/llvm/operators/math/atan_test.cpp delete mode 100644 test/llvm/operators/math/ceil_test.cpp delete mode 100644 test/llvm/operators/math/cos_test.cpp delete mode 100644 test/llvm/operators/math/divide_test.cpp delete mode 100644 test/llvm/operators/math/exp10_test.cpp delete mode 100644 test/llvm/operators/math/exp_test.cpp delete mode 100644 test/llvm/operators/math/floor_test.cpp delete mode 100644 test/llvm/operators/math/ln_test.cpp delete mode 100644 test/llvm/operators/math/log10_test.cpp delete mode 100644 test/llvm/operators/math/mod_test.cpp delete mode 100644 test/llvm/operators/math/multiply_test.cpp delete mode 100644 test/llvm/operators/math/random_int_test.cpp delete mode 100644 test/llvm/operators/math/random_test.cpp delete mode 100644 test/llvm/operators/math/round_test.cpp delete mode 100644 test/llvm/operators/math/sin_test.cpp delete mode 100644 test/llvm/operators/math/sqrt_test.cpp delete mode 100644 test/llvm/operators/math/subtract_test.cpp delete mode 100644 test/llvm/operators/math/tan_test.cpp delete mode 100644 test/llvm/operators/string/string_char_test.cpp delete mode 100644 test/llvm/operators/string/string_concat_test.cpp delete mode 100644 test/llvm/operators/string/string_equal_case_insensitive_test.cpp delete mode 100644 test/llvm/operators/string/string_equal_case_sensitive_test.cpp delete mode 100644 test/llvm/operators/string/string_length_test.cpp diff --git a/test/codegen/CMakeLists.txt b/test/codegen/CMakeLists.txt index 0cffa65c1..0037124b2 100644 --- a/test/codegen/CMakeLists.txt +++ b/test/codegen/CMakeLists.txt @@ -19,6 +19,39 @@ add_executable( codebuilder_test.cpp codegentestutils.cpp codegentestutils.h + operators/equal_comparison_test.cpp + operators/greater_than_test.cpp + operators/less_than_test.cpp + operators/math/add_test.cpp + operators/math/subtract_test.cpp + operators/math/multiply_test.cpp + operators/math/divide_test.cpp + operators/math/random_test.cpp + operators/math/random_int_test.cpp + operators/math/mod_test.cpp + operators/math/abs_test.cpp + operators/math/round_test.cpp + operators/math/floor_test.cpp + operators/math/ceil_test.cpp + operators/math/sqrt_test.cpp + operators/math/sin_test.cpp + operators/math/cos_test.cpp + operators/math/tan_test.cpp + operators/math/asin_test.cpp + operators/math/acos_test.cpp + operators/math/atan_test.cpp + operators/math/ln_test.cpp + operators/math/log10_test.cpp + operators/math/exp_test.cpp + operators/math/exp10_test.cpp + operators/logic/and_test.cpp + operators/logic/or_test.cpp + operators/logic/not_test.cpp + operators/string/string_equal_case_sensitive_test.cpp + operators/string/string_equal_case_insensitive_test.cpp + operators/string/string_concat_test.cpp + operators/string/string_char_test.cpp + operators/string/string_length_test.cpp ) target_link_libraries( diff --git a/test/codegen/operators/equal_comparison_test.cpp b/test/codegen/operators/equal_comparison_test.cpp new file mode 100644 index 000000000..38f20ca19 --- /dev/null +++ b/test/codegen/operators/equal_comparison_test.cpp @@ -0,0 +1,1205 @@ +#include +#include + +#include "codegentestutils.h" + +class EqualComparisonTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(EqualComparisonTest, SameIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 10, 10); +} + +TEST_F(EqualComparisonTest, SameIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 10, 10); +} + +TEST_F(EqualComparisonTest, DifferentIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 10, 8); +} + +TEST_F(EqualComparisonTest, DifferentIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 10, 8); +} + +TEST_F(EqualComparisonTest, DifferentIntegersReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 8, 10); +} + +TEST_F(EqualComparisonTest, DifferentIntegersReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 8, 10); +} + +TEST_F(EqualComparisonTest, SameDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, -4.25, -4.25); +} + +TEST_F(EqualComparisonTest, SameDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, -4.25, -4.25); +} + +TEST_F(EqualComparisonTest, DifferentDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, -4.25, 5.312); +} + +TEST_F(EqualComparisonTest, DifferentDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, -4.25, 5.312); +} + +TEST_F(EqualComparisonTest, DifferentDecimalsReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.312, -4.25); +} + +TEST_F(EqualComparisonTest, DifferentDecimalsReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.312, -4.25); +} + +TEST_F(EqualComparisonTest, SameBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, true); +} + +TEST_F(EqualComparisonTest, SameBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, true); +} + +TEST_F(EqualComparisonTest, DifferentBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, false); +} + +TEST_F(EqualComparisonTest, DifferentBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, false); +} + +TEST_F(EqualComparisonTest, DifferentBooleansReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, true); +} + +TEST_F(EqualComparisonTest, DifferentBooleansReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, true); +} + +TEST_F(EqualComparisonTest, NumberWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 1, true); +} + +TEST_F(EqualComparisonTest, NumberWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 1, true); +} + +TEST_F(EqualComparisonTest, NumberWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 1, false); +} + +TEST_F(EqualComparisonTest, NumberWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 1, false); +} + +TEST_F(EqualComparisonTest, SameStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "abC def", "abC def"); +} + +TEST_F(EqualComparisonTest, SameStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "abC def", "abC def"); +} + +TEST_F(EqualComparisonTest, StringsCaseDifferent) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "abC def", "abc dEf"); +} + +TEST_F(EqualComparisonTest, StringsCaseDifferent_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "abC def", "abc dEf"); +} + +TEST_F(EqualComparisonTest, DifferentStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "abC def", "ghi Jkl"); +} + +TEST_F(EqualComparisonTest, DifferentStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "abC def", "ghi Jkl"); +} + +TEST_F(EqualComparisonTest, DifferentStringsLonger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "abC def", "hello world"); +} + +TEST_F(EqualComparisonTest, DifferentStringsLonger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "abC def", "hello world"); +} + +TEST_F(EqualComparisonTest, SpaceVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, " ", ""); +} + +TEST_F(EqualComparisonTest, SpaceVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, " ", ""); +} + +TEST_F(EqualComparisonTest, SpaceVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, " ", "0"); +} + +TEST_F(EqualComparisonTest, SpaceVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, " ", "0"); +} + +TEST_F(EqualComparisonTest, SpaceVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, " ", 0); +} + +TEST_F(EqualComparisonTest, SpaceVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, " ", 0); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, " "); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, " "); +} + +TEST_F(EqualComparisonTest, EmptyVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "", "0"); +} + +TEST_F(EqualComparisonTest, EmptyVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "", "0"); +} + +TEST_F(EqualComparisonTest, EmptyVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "", 0); +} + +TEST_F(EqualComparisonTest, EmptyVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "", 0); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, ""); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, ""); +} + +TEST_F(EqualComparisonTest, ZeroStringVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "0", 0); +} + +TEST_F(EqualComparisonTest, ZeroStringVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "0", 0); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "0"); +} + +TEST_F(EqualComparisonTest, ZeroNumberVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "0"); +} + +TEST_F(EqualComparisonTest, NumberVsExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.25, "5.25"); +} + +TEST_F(EqualComparisonTest, NumberVsExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.25, "5.25"); +} + +TEST_F(EqualComparisonTest, ExactStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "5.25", 5.25); +} + +TEST_F(EqualComparisonTest, ExactStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "5.25", 5.25); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithLeadingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.25, " 5.25"); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithLeadingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.25, " 5.25"); +} + +TEST_F(EqualComparisonTest, StringWithLeadingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, " 5.25", 5.25); +} + +TEST_F(EqualComparisonTest, StringWithLeadingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, " 5.25", 5.25); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithTrailingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.25, "5.25 "); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithTrailingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.25, "5.25 "); +} + +TEST_F(EqualComparisonTest, StringWithTrailingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "5.25 ", 5.25); +} + +TEST_F(EqualComparisonTest, StringWithTrailingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "5.25 ", 5.25); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithSurroundingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.25, " 5.25 "); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithSurroundingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.25, " 5.25 "); +} + +TEST_F(EqualComparisonTest, StringWithSurroundingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, " 5.25 ", 5.25); +} + +TEST_F(EqualComparisonTest, StringWithSurroundingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, " 5.25 ", 5.25); +} + +TEST_F(EqualComparisonTest, NumberVsDifferentString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5.25, "5.26"); +} + +TEST_F(EqualComparisonTest, NumberVsDifferentString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5.25, "5.26"); +} + +TEST_F(EqualComparisonTest, DifferentStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "5.26", 5.25); +} + +TEST_F(EqualComparisonTest, DifferentStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "5.26", 5.25); +} + +TEST_F(EqualComparisonTest, DifferentStringNumbers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "5.25", "5.26"); +} + +TEST_F(EqualComparisonTest, DifferentStringNumbers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "5.25", "5.26"); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithTrailingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5, "5 "); +} + +TEST_F(EqualComparisonTest, NumberVsStringWithTrailingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5, "5 "); +} + +TEST_F(EqualComparisonTest, StringWithTrailingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "5 ", 5); +} + +TEST_F(EqualComparisonTest, StringWithTrailingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "5 ", 5); +} + +TEST_F(EqualComparisonTest, ZeroVsOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "1"); +} + +TEST_F(EqualComparisonTest, ZeroVsOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "1"); +} + +TEST_F(EqualComparisonTest, OneStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "1", 0); +} + +TEST_F(EqualComparisonTest, OneStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "1", 0); +} + +TEST_F(EqualComparisonTest, ZeroVsTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "test"); +} + +TEST_F(EqualComparisonTest, ZeroVsTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "test"); +} + +TEST_F(EqualComparisonTest, TestStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "test", 0); +} + +TEST_F(EqualComparisonTest, TestStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "test", 0); +} + +TEST_F(EqualComparisonTest, InfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NaNWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "NaN"); +} + +TEST_F(EqualComparisonTest, NaNWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "NaN"); +} + +TEST_F(EqualComparisonTest, InfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, InfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NaNWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "Infinity"); +} + +TEST_F(EqualComparisonTest, NaNWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NaNWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NaNWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NumberWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5, "Infinity"); +} + +TEST_F(EqualComparisonTest, NumberWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5, "Infinity"); +} + +TEST_F(EqualComparisonTest, NumberWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5, "-Infinity"); +} + +TEST_F(EqualComparisonTest, NumberWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5, "-Infinity"); +} + +TEST_F(EqualComparisonTest, NumberWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 5, "NaN"); +} + +TEST_F(EqualComparisonTest, NumberWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 5, "NaN"); +} + +TEST_F(EqualComparisonTest, ZeroWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "NaN"); +} + +TEST_F(EqualComparisonTest, ZeroWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "NaN"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "true"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "true"); +} + +TEST_F(EqualComparisonTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", true); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "false"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "false"); +} + +TEST_F(EqualComparisonTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", false); +} + +TEST_F(EqualComparisonTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", false); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "true"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "true"); +} + +TEST_F(EqualComparisonTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", false); +} + +TEST_F(EqualComparisonTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "true", false); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "false"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "false"); +} + +TEST_F(EqualComparisonTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", true); +} + +TEST_F(EqualComparisonTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", true); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "TRUE"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "TRUE"); +} + +TEST_F(EqualComparisonTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "TRUE", true); +} + +TEST_F(EqualComparisonTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "TRUE", true); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "FALSE"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "FALSE"); +} + +TEST_F(EqualComparisonTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "FALSE", false); +} + +TEST_F(EqualComparisonTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "FALSE", false); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "00001"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "00001"); +} + +TEST_F(EqualComparisonTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "00001", true); +} + +TEST_F(EqualComparisonTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "00001", true); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "00000"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "00000"); +} + +TEST_F(EqualComparisonTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "00000", true); +} + +TEST_F(EqualComparisonTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "00000", true); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "00000"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "00000"); +} + +TEST_F(EqualComparisonTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "00000", false); +} + +TEST_F(EqualComparisonTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "00000", false); +} + +TEST_F(EqualComparisonTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", 1); +} + +TEST_F(EqualComparisonTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "true", 1); +} + +TEST_F(EqualComparisonTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 1, "true"); +} + +TEST_F(EqualComparisonTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 1, "true"); +} + +TEST_F(EqualComparisonTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", 0); +} + +TEST_F(EqualComparisonTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "true", 0); +} + +TEST_F(EqualComparisonTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "true"); +} + +TEST_F(EqualComparisonTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "true"); +} + +TEST_F(EqualComparisonTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", 0); +} + +TEST_F(EqualComparisonTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", 0); +} + +TEST_F(EqualComparisonTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 0, "false"); +} + +TEST_F(EqualComparisonTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 0, "false"); +} + +TEST_F(EqualComparisonTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", 1); +} + +TEST_F(EqualComparisonTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", 1); +} + +TEST_F(EqualComparisonTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, 1, "false"); +} + +TEST_F(EqualComparisonTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, 1, "false"); +} + +TEST_F(EqualComparisonTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", "TRUE"); +} + +TEST_F(EqualComparisonTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "true", "TRUE"); +} + +TEST_F(EqualComparisonTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "true", "FALSE"); +} + +TEST_F(EqualComparisonTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "true", "FALSE"); +} + +TEST_F(EqualComparisonTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", "FALSE"); +} + +TEST_F(EqualComparisonTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", "FALSE"); +} + +TEST_F(EqualComparisonTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "false", "TRUE"); +} + +TEST_F(EqualComparisonTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "false", "TRUE"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "Infinity"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "Infinity"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "-Infinity"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "-Infinity"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, true, "NaN"); +} + +TEST_F(EqualComparisonTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, true, "NaN"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "Infinity"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "Infinity"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "-Infinity"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "-Infinity"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, false, "NaN"); +} + +TEST_F(EqualComparisonTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, false, "NaN"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-infinity", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-infinity", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-infinity", "NaN"); +} + +TEST_F(EqualComparisonTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "Infinity"); +} + +TEST_F(EqualComparisonTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "Infinity"); +} + +TEST_F(EqualComparisonTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "-Infinity"); +} + +TEST_F(EqualComparisonTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "NaN"); +} + +TEST_F(EqualComparisonTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "nan", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "nan", "Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "nan", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "nan", "-Infinity"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "nan", "NaN"); +} + +TEST_F(EqualComparisonTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "nan", "NaN"); +} + +TEST_F(EqualComparisonTest, InfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "abc"); +} + +TEST_F(EqualComparisonTest, InfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "abc"); +} + +TEST_F(EqualComparisonTest, InfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", " "); +} + +TEST_F(EqualComparisonTest, InfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", " "); +} + +TEST_F(EqualComparisonTest, InfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", ""); +} + +TEST_F(EqualComparisonTest, InfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", ""); +} + +TEST_F(EqualComparisonTest, InfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "Infinity", "0"); +} + +TEST_F(EqualComparisonTest, InfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "Infinity", "0"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "abc"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "abc"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", " "); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", " "); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", ""); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", ""); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "-Infinity", "0"); +} + +TEST_F(EqualComparisonTest, NegativeInfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "-Infinity", "0"); +} + +TEST_F(EqualComparisonTest, NaNWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "abc"); +} + +TEST_F(EqualComparisonTest, NaNWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "abc"); +} + +TEST_F(EqualComparisonTest, NaNWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", " "); +} + +TEST_F(EqualComparisonTest, NaNWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", " "); +} + +TEST_F(EqualComparisonTest, NaNWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", ""); +} + +TEST_F(EqualComparisonTest, NaNWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", ""); +} + +TEST_F(EqualComparisonTest, NaNWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, false, "NaN", "0"); +} + +TEST_F(EqualComparisonTest, NaNWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpEQ, true, "NaN", "0"); +} diff --git a/test/codegen/operators/greater_than_test.cpp b/test/codegen/operators/greater_than_test.cpp new file mode 100644 index 000000000..d773a4461 --- /dev/null +++ b/test/codegen/operators/greater_than_test.cpp @@ -0,0 +1,1340 @@ +#include +#include + +#include "codegentestutils.h" + +class GreaterThanTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(GreaterThanTest, SameIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 10, 10); +} + +TEST_F(GreaterThanTest, SameIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 10, 10); +} + +TEST_F(GreaterThanTest, FirstGreaterInteger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 10, 8); +} + +TEST_F(GreaterThanTest, FirstGreaterInteger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 10, 8); +} + +TEST_F(GreaterThanTest, SecondGreaterInteger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 8, 10); +} + +TEST_F(GreaterThanTest, SecondGreaterInteger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 8, 10); +} + +TEST_F(GreaterThanTest, SameDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, -4.25, -4.25); +} + +TEST_F(GreaterThanTest, SameDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, -4.25, -4.25); +} + +TEST_F(GreaterThanTest, FirstGreaterDecimal) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, -4.25, 5.312); +} + +TEST_F(GreaterThanTest, FirstGreaterDecimal_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, -4.25, 5.312); +} + +TEST_F(GreaterThanTest, SecondGreaterDecimal) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.312, -4.25); +} + +TEST_F(GreaterThanTest, SecondGreaterDecimal_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.312, -4.25); +} + +TEST_F(GreaterThanTest, SameBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, true); +} + +TEST_F(GreaterThanTest, SameBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, true); +} + +TEST_F(GreaterThanTest, TrueGreaterThanFalse) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, false); +} + +TEST_F(GreaterThanTest, TrueGreaterThanFalse_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, false); +} + +TEST_F(GreaterThanTest, FalseGreaterThanTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, true); +} + +TEST_F(GreaterThanTest, FalseGreaterThanTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, true); +} + +TEST_F(GreaterThanTest, NumberGreaterThanTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 1, true); +} + +TEST_F(GreaterThanTest, NumberGreaterThanTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 1, true); +} + +TEST_F(GreaterThanTest, NumberGreaterThanFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 1, false); +} + +TEST_F(GreaterThanTest, NumberGreaterThanFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 1, false); +} + +TEST_F(GreaterThanTest, SameStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "abC def", "abC def"); +} + +TEST_F(GreaterThanTest, SameStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "abC def", "abC def"); +} + +TEST_F(GreaterThanTest, StringsCaseDifferent) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "abC def", "abc dEf"); +} + +TEST_F(GreaterThanTest, StringsCaseDifferent_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "abC def", "abc dEf"); +} + +TEST_F(GreaterThanTest, FirstStringGreater) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "abC def", "ghi Jkl"); +} + +TEST_F(GreaterThanTest, FirstStringGreater_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "abC def", "ghi Jkl"); +} + +TEST_F(GreaterThanTest, SecondStringGreater) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "ghi Jkl", "abC def"); +} + +TEST_F(GreaterThanTest, SecondStringGreater_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "ghi Jkl", "abC def"); +} + +TEST_F(GreaterThanTest, StringsLengthComparison) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "abC def", "hello world"); +} + +TEST_F(GreaterThanTest, StringsLengthComparison_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "abC def", "hello world"); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, " ", ""); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, " ", ""); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, " ", "0"); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, " ", "0"); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, " ", 0); +} + +TEST_F(GreaterThanTest, SpaceGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, " ", 0); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, " "); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, " "); +} + +TEST_F(GreaterThanTest, EmptyGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "", "0"); +} + +TEST_F(GreaterThanTest, EmptyGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "", "0"); +} + +TEST_F(GreaterThanTest, EmptyGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "", 0); +} + +TEST_F(GreaterThanTest, EmptyGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "", 0); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, ""); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, ""); +} + +TEST_F(GreaterThanTest, ZeroStringGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "0", 0); +} + +TEST_F(GreaterThanTest, ZeroStringGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "0", 0); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "0"); +} + +TEST_F(GreaterThanTest, ZeroNumberGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "0"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.25, "5.25"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.25, "5.25"); +} + +TEST_F(GreaterThanTest, ExactStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "5.25", 5.25); +} + +TEST_F(GreaterThanTest, ExactStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "5.25", 5.25); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithLeadingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.25, " 5.25"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithLeadingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.25, " 5.25"); +} + +TEST_F(GreaterThanTest, StringWithLeadingSpaceGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, " 5.25", 5.25); +} + +TEST_F(GreaterThanTest, StringWithLeadingSpaceGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, " 5.25", 5.25); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithTrailingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.25, "5.25 "); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithTrailingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.25, "5.25 "); +} + +TEST_F(GreaterThanTest, StringWithTrailingSpaceGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "5.25 ", 5.25); +} + +TEST_F(GreaterThanTest, StringWithTrailingSpaceGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "5.25 ", 5.25); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithSurroundingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.25, " 5.25 "); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithSurroundingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.25, " 5.25 "); +} + +TEST_F(GreaterThanTest, StringWithSurroundingSpacesGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, " 5.25 ", 5.25); +} + +TEST_F(GreaterThanTest, StringWithSurroundingSpacesGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, " 5.25 ", 5.25); +} + +TEST_F(GreaterThanTest, NumberGreaterThanDifferentString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5.25, "5.26"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanDifferentString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5.25, "5.26"); +} + +TEST_F(GreaterThanTest, DifferentStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "5.26", 5.25); +} + +TEST_F(GreaterThanTest, DifferentStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "5.26", 5.25); +} + +TEST_F(GreaterThanTest, DifferentStringNumbers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "5.25", "5.26"); +} + +TEST_F(GreaterThanTest, DifferentStringNumbers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "5.25", "5.26"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithTrailingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5, "5 "); +} + +TEST_F(GreaterThanTest, NumberGreaterThanStringWithTrailingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5, "5 "); +} + +TEST_F(GreaterThanTest, StringWithTrailingSpacesGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "5 ", 5); +} + +TEST_F(GreaterThanTest, StringWithTrailingSpacesGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "5 ", 5); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "1"); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "1"); +} + +TEST_F(GreaterThanTest, OneStringGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "1", 0); +} + +TEST_F(GreaterThanTest, OneStringGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "1", 0); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "test"); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "test"); +} + +TEST_F(GreaterThanTest, TestStringGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "test", 0); +} + +TEST_F(GreaterThanTest, TestStringGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "test", 0); +} + +TEST_F(GreaterThanTest, NumberGreaterThanAbcString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 55, "abc"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanAbcString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 55, "abc"); +} + +TEST_F(GreaterThanTest, AbcStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "abc", 55); +} + +TEST_F(GreaterThanTest, AbcStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "abc", 55); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "NaN"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "NaN"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "Infinity"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "-Infinity"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "-Infinity"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5, "Infinity"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5, "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", 5); +} + +TEST_F(GreaterThanTest, InfinityGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", 5); +} + +TEST_F(GreaterThanTest, NumberGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5, "-Infinity"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5, "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", 5); +} + +TEST_F(GreaterThanTest, NegativeInfinityGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", 5); +} + +TEST_F(GreaterThanTest, NumberGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 5, "NaN"); +} + +TEST_F(GreaterThanTest, NumberGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 5, "NaN"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", 5); +} + +TEST_F(GreaterThanTest, NaNGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", 5); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "NaN"); +} + +TEST_F(GreaterThanTest, ZeroGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "NaN"); +} + +TEST_F(GreaterThanTest, NaNGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", 0); +} + +TEST_F(GreaterThanTest, NaNGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", 0); +} + +TEST_F(GreaterThanTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "true"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "true"); +} + +TEST_F(GreaterThanTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", true); +} + +TEST_F(GreaterThanTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", true); +} + +TEST_F(GreaterThanTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "false"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "false"); +} + +TEST_F(GreaterThanTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", false); +} + +TEST_F(GreaterThanTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", false); +} + +TEST_F(GreaterThanTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "true"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "true"); +} + +TEST_F(GreaterThanTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", false); +} + +TEST_F(GreaterThanTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", false); +} + +TEST_F(GreaterThanTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "false"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "false"); +} + +TEST_F(GreaterThanTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", true); +} + +TEST_F(GreaterThanTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", true); +} + +TEST_F(GreaterThanTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "TRUE"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "TRUE"); +} + +TEST_F(GreaterThanTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "TRUE", true); +} + +TEST_F(GreaterThanTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "TRUE", true); +} + +TEST_F(GreaterThanTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "FALSE"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "FALSE"); +} + +TEST_F(GreaterThanTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "FALSE", false); +} + +TEST_F(GreaterThanTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "FALSE", false); +} + +TEST_F(GreaterThanTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "00001"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "00001"); +} + +TEST_F(GreaterThanTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "00001", true); +} + +TEST_F(GreaterThanTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "00001", true); +} + +TEST_F(GreaterThanTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "00000"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "00000"); +} + +TEST_F(GreaterThanTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "00000", true); +} + +TEST_F(GreaterThanTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "00000", true); +} + +TEST_F(GreaterThanTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "00000"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "00000"); +} + +TEST_F(GreaterThanTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "00000", false); +} + +TEST_F(GreaterThanTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "00000", false); +} + +TEST_F(GreaterThanTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", 1); +} + +TEST_F(GreaterThanTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", 1); +} + +TEST_F(GreaterThanTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 1, "true"); +} + +TEST_F(GreaterThanTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 1, "true"); +} + +TEST_F(GreaterThanTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", 0); +} + +TEST_F(GreaterThanTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", 0); +} + +TEST_F(GreaterThanTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "true"); +} + +TEST_F(GreaterThanTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "true"); +} + +TEST_F(GreaterThanTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", 0); +} + +TEST_F(GreaterThanTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", 0); +} + +TEST_F(GreaterThanTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 0, "false"); +} + +TEST_F(GreaterThanTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 0, "false"); +} + +TEST_F(GreaterThanTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", 1); +} + +TEST_F(GreaterThanTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", 1); +} + +TEST_F(GreaterThanTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, 1, "false"); +} + +TEST_F(GreaterThanTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, 1, "false"); +} + +TEST_F(GreaterThanTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", "TRUE"); +} + +TEST_F(GreaterThanTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", "TRUE"); +} + +TEST_F(GreaterThanTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "true", "FALSE"); +} + +TEST_F(GreaterThanTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "true", "FALSE"); +} + +TEST_F(GreaterThanTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", "FALSE"); +} + +TEST_F(GreaterThanTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", "FALSE"); +} + +TEST_F(GreaterThanTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "false", "TRUE"); +} + +TEST_F(GreaterThanTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "false", "TRUE"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "Infinity"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", true); +} + +TEST_F(GreaterThanTest, InfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", true); +} + +TEST_F(GreaterThanTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "-Infinity"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", true); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", true); +} + +TEST_F(GreaterThanTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, true, "NaN"); +} + +TEST_F(GreaterThanTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, true, "NaN"); +} + +TEST_F(GreaterThanTest, NaNWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", true); +} + +TEST_F(GreaterThanTest, NaNWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", true); +} + +TEST_F(GreaterThanTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "Infinity"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", false); +} + +TEST_F(GreaterThanTest, InfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", false); +} + +TEST_F(GreaterThanTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "-Infinity"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", false); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", false); +} + +TEST_F(GreaterThanTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, false, "NaN"); +} + +TEST_F(GreaterThanTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, false, "NaN"); +} + +TEST_F(GreaterThanTest, NaNWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", false); +} + +TEST_F(GreaterThanTest, NaNWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", false); +} + +TEST_F(GreaterThanTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "infinity", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-infinity", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-infinity", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-infinity", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-infinity", "NaN"); +} + +TEST_F(GreaterThanTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "Infinity"); +} + +TEST_F(GreaterThanTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "Infinity"); +} + +TEST_F(GreaterThanTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "-Infinity"); +} + +TEST_F(GreaterThanTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "-Infinity"); +} + +TEST_F(GreaterThanTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "NaN"); +} + +TEST_F(GreaterThanTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "nan", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "nan", "Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "nan", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "nan", "-Infinity"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "nan", "NaN"); +} + +TEST_F(GreaterThanTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "nan", "NaN"); +} + +TEST_F(GreaterThanTest, InfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "abc"); +} + +TEST_F(GreaterThanTest, InfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "abc"); +} + +TEST_F(GreaterThanTest, InfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", " "); +} + +TEST_F(GreaterThanTest, InfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", " "); +} + +TEST_F(GreaterThanTest, InfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", ""); +} + +TEST_F(GreaterThanTest, InfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", ""); +} + +TEST_F(GreaterThanTest, InfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "Infinity", "0"); +} + +TEST_F(GreaterThanTest, InfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "Infinity", "0"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "abc"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "abc"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", " "); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", " "); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", ""); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", ""); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "-Infinity", "0"); +} + +TEST_F(GreaterThanTest, NegativeInfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "-Infinity", "0"); +} + +TEST_F(GreaterThanTest, NaNWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "abc"); +} + +TEST_F(GreaterThanTest, NaNWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "abc"); +} + +TEST_F(GreaterThanTest, NaNWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", " "); +} + +TEST_F(GreaterThanTest, NaNWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", " "); +} + +TEST_F(GreaterThanTest, NaNWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", ""); +} + +TEST_F(GreaterThanTest, NaNWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", ""); +} + +TEST_F(GreaterThanTest, NaNWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, false, "NaN", "0"); +} + +TEST_F(GreaterThanTest, NaNWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpGT, true, "NaN", "0"); +} diff --git a/test/codegen/operators/less_than_test.cpp b/test/codegen/operators/less_than_test.cpp new file mode 100644 index 000000000..2ffaf7f98 --- /dev/null +++ b/test/codegen/operators/less_than_test.cpp @@ -0,0 +1,1340 @@ +#include +#include + +#include "codegentestutils.h" + +class LessThanTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(LessThanTest, SameIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 10, 10); +} + +TEST_F(LessThanTest, SameIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 10, 10); +} + +TEST_F(LessThanTest, FirstGreaterInteger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 10, 8); +} + +TEST_F(LessThanTest, FirstGreaterInteger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 10, 8); +} + +TEST_F(LessThanTest, SecondGreaterInteger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 8, 10); +} + +TEST_F(LessThanTest, SecondGreaterInteger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 8, 10); +} + +TEST_F(LessThanTest, SameDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, -4.25, -4.25); +} + +TEST_F(LessThanTest, SameDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, -4.25, -4.25); +} + +TEST_F(LessThanTest, FirstGreaterDecimal) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, -4.25, 5.312); +} + +TEST_F(LessThanTest, FirstGreaterDecimal_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, -4.25, 5.312); +} + +TEST_F(LessThanTest, SecondGreaterDecimal) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.312, -4.25); +} + +TEST_F(LessThanTest, SecondGreaterDecimal_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.312, -4.25); +} + +TEST_F(LessThanTest, SameBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, true); +} + +TEST_F(LessThanTest, SameBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, true); +} + +TEST_F(LessThanTest, TrueGreaterThanFalse) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, false); +} + +TEST_F(LessThanTest, TrueGreaterThanFalse_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, false); +} + +TEST_F(LessThanTest, FalseGreaterThanTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, true); +} + +TEST_F(LessThanTest, FalseGreaterThanTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, true); +} + +TEST_F(LessThanTest, NumberGreaterThanTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 1, true); +} + +TEST_F(LessThanTest, NumberGreaterThanTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 1, true); +} + +TEST_F(LessThanTest, NumberGreaterThanFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 1, false); +} + +TEST_F(LessThanTest, NumberGreaterThanFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 1, false); +} + +TEST_F(LessThanTest, SameStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "abC def", "abC def"); +} + +TEST_F(LessThanTest, SameStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "abC def", "abC def"); +} + +TEST_F(LessThanTest, StringsCaseDifferent) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "abC def", "abc dEf"); +} + +TEST_F(LessThanTest, StringsCaseDifferent_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "abC def", "abc dEf"); +} + +TEST_F(LessThanTest, FirstStringGreater) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "abC def", "ghi Jkl"); +} + +TEST_F(LessThanTest, FirstStringGreater_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "abC def", "ghi Jkl"); +} + +TEST_F(LessThanTest, SecondStringGreater) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "ghi Jkl", "abC def"); +} + +TEST_F(LessThanTest, SecondStringGreater_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "ghi Jkl", "abC def"); +} + +TEST_F(LessThanTest, StringsLengthComparison) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "abC def", "hello world"); +} + +TEST_F(LessThanTest, StringsLengthComparison_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "abC def", "hello world"); +} + +TEST_F(LessThanTest, SpaceGreaterThanEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, " ", ""); +} + +TEST_F(LessThanTest, SpaceGreaterThanEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, " ", ""); +} + +TEST_F(LessThanTest, SpaceGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, " ", "0"); +} + +TEST_F(LessThanTest, SpaceGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, " ", "0"); +} + +TEST_F(LessThanTest, SpaceGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, " ", 0); +} + +TEST_F(LessThanTest, SpaceGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, " ", 0); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, " "); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, " "); +} + +TEST_F(LessThanTest, EmptyGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "", "0"); +} + +TEST_F(LessThanTest, EmptyGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "", "0"); +} + +TEST_F(LessThanTest, EmptyGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "", 0); +} + +TEST_F(LessThanTest, EmptyGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "", 0); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, ""); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, ""); +} + +TEST_F(LessThanTest, ZeroStringGreaterThanZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "0", 0); +} + +TEST_F(LessThanTest, ZeroStringGreaterThanZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "0", 0); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "0"); +} + +TEST_F(LessThanTest, ZeroNumberGreaterThanZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "0"); +} + +TEST_F(LessThanTest, NumberGreaterThanExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.25, "5.25"); +} + +TEST_F(LessThanTest, NumberGreaterThanExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.25, "5.25"); +} + +TEST_F(LessThanTest, ExactStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "5.25", 5.25); +} + +TEST_F(LessThanTest, ExactStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "5.25", 5.25); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithLeadingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.25, " 5.25"); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithLeadingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.25, " 5.25"); +} + +TEST_F(LessThanTest, StringWithLeadingSpaceGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, " 5.25", 5.25); +} + +TEST_F(LessThanTest, StringWithLeadingSpaceGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, " 5.25", 5.25); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithTrailingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.25, "5.25 "); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithTrailingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.25, "5.25 "); +} + +TEST_F(LessThanTest, StringWithTrailingSpaceGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "5.25 ", 5.25); +} + +TEST_F(LessThanTest, StringWithTrailingSpaceGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "5.25 ", 5.25); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithSurroundingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.25, " 5.25 "); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithSurroundingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.25, " 5.25 "); +} + +TEST_F(LessThanTest, StringWithSurroundingSpacesGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, " 5.25 ", 5.25); +} + +TEST_F(LessThanTest, StringWithSurroundingSpacesGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, " 5.25 ", 5.25); +} + +TEST_F(LessThanTest, NumberGreaterThanDifferentString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5.25, "5.26"); +} + +TEST_F(LessThanTest, NumberGreaterThanDifferentString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5.25, "5.26"); +} + +TEST_F(LessThanTest, DifferentStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "5.26", 5.25); +} + +TEST_F(LessThanTest, DifferentStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "5.26", 5.25); +} + +TEST_F(LessThanTest, DifferentStringNumbers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "5.25", "5.26"); +} + +TEST_F(LessThanTest, DifferentStringNumbers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "5.25", "5.26"); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithTrailingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5, "5 "); +} + +TEST_F(LessThanTest, NumberGreaterThanStringWithTrailingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5, "5 "); +} + +TEST_F(LessThanTest, StringWithTrailingSpacesGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "5 ", 5); +} + +TEST_F(LessThanTest, StringWithTrailingSpacesGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "5 ", 5); +} + +TEST_F(LessThanTest, ZeroGreaterThanOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "1"); +} + +TEST_F(LessThanTest, ZeroGreaterThanOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "1"); +} + +TEST_F(LessThanTest, OneStringGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "1", 0); +} + +TEST_F(LessThanTest, OneStringGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "1", 0); +} + +TEST_F(LessThanTest, ZeroGreaterThanTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "test"); +} + +TEST_F(LessThanTest, ZeroGreaterThanTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "test"); +} + +TEST_F(LessThanTest, TestStringGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "test", 0); +} + +TEST_F(LessThanTest, TestStringGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "test", 0); +} + +TEST_F(LessThanTest, NumberGreaterThanAbcString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 55, "abc"); +} + +TEST_F(LessThanTest, NumberGreaterThanAbcString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 55, "abc"); +} + +TEST_F(LessThanTest, AbcStringGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "abc", 55); +} + +TEST_F(LessThanTest, AbcStringGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "abc", 55); +} + +TEST_F(LessThanTest, InfinityGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "Infinity"); +} + +TEST_F(LessThanTest, InfinityGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, NaNGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "NaN"); +} + +TEST_F(LessThanTest, NaNGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "NaN"); +} + +TEST_F(LessThanTest, InfinityGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, InfinityGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "Infinity"); +} + +TEST_F(LessThanTest, InfinityGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "NaN"); +} + +TEST_F(LessThanTest, InfinityGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "NaN"); +} + +TEST_F(LessThanTest, NaNGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "Infinity"); +} + +TEST_F(LessThanTest, NaNGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "NaN"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "NaN"); +} + +TEST_F(LessThanTest, NaNGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "-Infinity"); +} + +TEST_F(LessThanTest, NaNGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "-Infinity"); +} + +TEST_F(LessThanTest, NumberGreaterThanInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5, "Infinity"); +} + +TEST_F(LessThanTest, NumberGreaterThanInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5, "Infinity"); +} + +TEST_F(LessThanTest, InfinityGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", 5); +} + +TEST_F(LessThanTest, InfinityGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", 5); +} + +TEST_F(LessThanTest, NumberGreaterThanNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5, "-Infinity"); +} + +TEST_F(LessThanTest, NumberGreaterThanNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5, "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", 5); +} + +TEST_F(LessThanTest, NegativeInfinityGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", 5); +} + +TEST_F(LessThanTest, NumberGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 5, "NaN"); +} + +TEST_F(LessThanTest, NumberGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 5, "NaN"); +} + +TEST_F(LessThanTest, NaNGreaterThanNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", 5); +} + +TEST_F(LessThanTest, NaNGreaterThanNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", 5); +} + +TEST_F(LessThanTest, ZeroGreaterThanNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "NaN"); +} + +TEST_F(LessThanTest, ZeroGreaterThanNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "NaN"); +} + +TEST_F(LessThanTest, NaNGreaterThanZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", 0); +} + +TEST_F(LessThanTest, NaNGreaterThanZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", 0); +} + +TEST_F(LessThanTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "true"); +} + +TEST_F(LessThanTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "true"); +} + +TEST_F(LessThanTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", true); +} + +TEST_F(LessThanTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", true); +} + +TEST_F(LessThanTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "false"); +} + +TEST_F(LessThanTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "false"); +} + +TEST_F(LessThanTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", false); +} + +TEST_F(LessThanTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", false); +} + +TEST_F(LessThanTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "true"); +} + +TEST_F(LessThanTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "true"); +} + +TEST_F(LessThanTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", false); +} + +TEST_F(LessThanTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", false); +} + +TEST_F(LessThanTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "false"); +} + +TEST_F(LessThanTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "false"); +} + +TEST_F(LessThanTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", true); +} + +TEST_F(LessThanTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", true); +} + +TEST_F(LessThanTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "TRUE"); +} + +TEST_F(LessThanTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "TRUE"); +} + +TEST_F(LessThanTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "TRUE", true); +} + +TEST_F(LessThanTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "TRUE", true); +} + +TEST_F(LessThanTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "FALSE"); +} + +TEST_F(LessThanTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "FALSE"); +} + +TEST_F(LessThanTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "FALSE", false); +} + +TEST_F(LessThanTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "FALSE", false); +} + +TEST_F(LessThanTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "00001"); +} + +TEST_F(LessThanTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "00001"); +} + +TEST_F(LessThanTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "00001", true); +} + +TEST_F(LessThanTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "00001", true); +} + +TEST_F(LessThanTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "00000"); +} + +TEST_F(LessThanTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "00000"); +} + +TEST_F(LessThanTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "00000", true); +} + +TEST_F(LessThanTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "00000", true); +} + +TEST_F(LessThanTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "00000"); +} + +TEST_F(LessThanTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "00000"); +} + +TEST_F(LessThanTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "00000", false); +} + +TEST_F(LessThanTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "00000", false); +} + +TEST_F(LessThanTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", 1); +} + +TEST_F(LessThanTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", 1); +} + +TEST_F(LessThanTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 1, "true"); +} + +TEST_F(LessThanTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 1, "true"); +} + +TEST_F(LessThanTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", 0); +} + +TEST_F(LessThanTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", 0); +} + +TEST_F(LessThanTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "true"); +} + +TEST_F(LessThanTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "true"); +} + +TEST_F(LessThanTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", 0); +} + +TEST_F(LessThanTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", 0); +} + +TEST_F(LessThanTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 0, "false"); +} + +TEST_F(LessThanTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 0, "false"); +} + +TEST_F(LessThanTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", 1); +} + +TEST_F(LessThanTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", 1); +} + +TEST_F(LessThanTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, 1, "false"); +} + +TEST_F(LessThanTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, 1, "false"); +} + +TEST_F(LessThanTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", "TRUE"); +} + +TEST_F(LessThanTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", "TRUE"); +} + +TEST_F(LessThanTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "true", "FALSE"); +} + +TEST_F(LessThanTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "true", "FALSE"); +} + +TEST_F(LessThanTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", "FALSE"); +} + +TEST_F(LessThanTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", "FALSE"); +} + +TEST_F(LessThanTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "false", "TRUE"); +} + +TEST_F(LessThanTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "false", "TRUE"); +} + +TEST_F(LessThanTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "Infinity"); +} + +TEST_F(LessThanTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "Infinity"); +} + +TEST_F(LessThanTest, InfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", true); +} + +TEST_F(LessThanTest, InfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", true); +} + +TEST_F(LessThanTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "-Infinity"); +} + +TEST_F(LessThanTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", true); +} + +TEST_F(LessThanTest, NegativeInfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", true); +} + +TEST_F(LessThanTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, true, "NaN"); +} + +TEST_F(LessThanTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, true, "NaN"); +} + +TEST_F(LessThanTest, NaNWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", true); +} + +TEST_F(LessThanTest, NaNWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", true); +} + +TEST_F(LessThanTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "Infinity"); +} + +TEST_F(LessThanTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "Infinity"); +} + +TEST_F(LessThanTest, InfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", false); +} + +TEST_F(LessThanTest, InfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", false); +} + +TEST_F(LessThanTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "-Infinity"); +} + +TEST_F(LessThanTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", false); +} + +TEST_F(LessThanTest, NegativeInfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", false); +} + +TEST_F(LessThanTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, false, "NaN"); +} + +TEST_F(LessThanTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, false, "NaN"); +} + +TEST_F(LessThanTest, NaNWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", false); +} + +TEST_F(LessThanTest, NaNWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", false); +} + +TEST_F(LessThanTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "Infinity"); +} + +TEST_F(LessThanTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "Infinity"); +} + +TEST_F(LessThanTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "NaN"); +} + +TEST_F(LessThanTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "NaN"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "infinity", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "infinity", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "infinity", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "infinity", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "infinity", "NaN"); +} + +TEST_F(LessThanTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "infinity", "NaN"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "-Infinity"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "NaN"); +} + +TEST_F(LessThanTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "NaN"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-infinity", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-infinity", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-infinity", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-infinity", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-infinity", "NaN"); +} + +TEST_F(LessThanTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-infinity", "NaN"); +} + +TEST_F(LessThanTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "Infinity"); +} + +TEST_F(LessThanTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "Infinity"); +} + +TEST_F(LessThanTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "-Infinity"); +} + +TEST_F(LessThanTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "-Infinity"); +} + +TEST_F(LessThanTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "NaN"); +} + +TEST_F(LessThanTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "NaN"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "nan", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "nan", "Infinity"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "nan", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "nan", "-Infinity"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "nan", "NaN"); +} + +TEST_F(LessThanTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "nan", "NaN"); +} + +TEST_F(LessThanTest, InfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "abc"); +} + +TEST_F(LessThanTest, InfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "abc"); +} + +TEST_F(LessThanTest, InfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", " "); +} + +TEST_F(LessThanTest, InfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", " "); +} + +TEST_F(LessThanTest, InfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", ""); +} + +TEST_F(LessThanTest, InfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", ""); +} + +TEST_F(LessThanTest, InfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "Infinity", "0"); +} + +TEST_F(LessThanTest, InfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "Infinity", "0"); +} + +TEST_F(LessThanTest, NegativeInfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "abc"); +} + +TEST_F(LessThanTest, NegativeInfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "abc"); +} + +TEST_F(LessThanTest, NegativeInfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", " "); +} + +TEST_F(LessThanTest, NegativeInfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", " "); +} + +TEST_F(LessThanTest, NegativeInfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", ""); +} + +TEST_F(LessThanTest, NegativeInfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", ""); +} + +TEST_F(LessThanTest, NegativeInfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "-Infinity", "0"); +} + +TEST_F(LessThanTest, NegativeInfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "-Infinity", "0"); +} + +TEST_F(LessThanTest, NaNWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "abc"); +} + +TEST_F(LessThanTest, NaNWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "abc"); +} + +TEST_F(LessThanTest, NaNWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", " "); +} + +TEST_F(LessThanTest, NaNWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", " "); +} + +TEST_F(LessThanTest, NaNWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", ""); +} + +TEST_F(LessThanTest, NaNWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", ""); +} + +TEST_F(LessThanTest, NaNWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, false, "NaN", "0"); +} + +TEST_F(LessThanTest, NaNWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::CmpLT, true, "NaN", "0"); +} diff --git a/test/codegen/operators/logic/and_test.cpp b/test/codegen/operators/logic/and_test.cpp new file mode 100644 index 000000000..13d313a28 --- /dev/null +++ b/test/codegen/operators/logic/and_test.cpp @@ -0,0 +1,890 @@ +#include +#include + +#include "codegentestutils.h" + +class AndTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AndTest, NumberWithNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 10, 8); +} + +TEST_F(AndTest, NumberWithNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 10, 8); +} + +TEST_F(AndTest, SameNegativeDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, -4.25, -4.25); +} + +TEST_F(AndTest, SameNegativeDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, -4.25, -4.25); +} + +TEST_F(AndTest, DifferentDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, -4.25, 5.312); +} + +TEST_F(AndTest, DifferentDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, -4.25, 5.312); +} + +TEST_F(AndTest, TrueAndTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, true); +} + +TEST_F(AndTest, TrueAndTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, true); +} + +TEST_F(AndTest, TrueAndFalse) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, false); +} + +TEST_F(AndTest, TrueAndFalse_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, false); +} + +TEST_F(AndTest, FalseAndTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, true); +} + +TEST_F(AndTest, FalseAndTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, true); +} + +TEST_F(AndTest, NumberAndTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 1, true); +} + +TEST_F(AndTest, NumberAndTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 1, true); +} + +TEST_F(AndTest, NumberAndFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 1, false); +} + +TEST_F(AndTest, NumberAndFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 1, false); +} + +TEST_F(AndTest, StringAndString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "abc", "def"); +} + +TEST_F(AndTest, StringAndString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "abc", "def"); +} + +TEST_F(AndTest, TrueStringAndTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", "true"); +} + +TEST_F(AndTest, TrueStringAndTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", "true"); +} + +TEST_F(AndTest, TrueStringAndFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", "false"); +} + +TEST_F(AndTest, TrueStringAndFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", "false"); +} + +TEST_F(AndTest, FalseStringAndTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", "true"); +} + +TEST_F(AndTest, FalseStringAndTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", "true"); +} + +TEST_F(AndTest, FalseStringAndFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", "false"); +} + +TEST_F(AndTest, FalseStringAndFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", "false"); +} + +TEST_F(AndTest, NumberAndExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 5.25, "5.25"); +} + +TEST_F(AndTest, NumberAndExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 5.25, "5.25"); +} + +TEST_F(AndTest, ExactStringAndNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "5.25", 5.25); +} + +TEST_F(AndTest, ExactStringAndNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "5.25", 5.25); +} + +TEST_F(AndTest, ZeroAndOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 0, "1"); +} + +TEST_F(AndTest, ZeroAndOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 0, "1"); +} + +TEST_F(AndTest, OneStringAndZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "1", 0); +} + +TEST_F(AndTest, OneStringAndZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "1", 0); +} + +TEST_F(AndTest, ZeroAndTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 0, "test"); +} + +TEST_F(AndTest, ZeroAndTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 0, "test"); +} + +TEST_F(AndTest, TestStringAndZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "test", 0); +} + +TEST_F(AndTest, TestStringAndZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "test", 0); +} + +TEST_F(AndTest, InfinityAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "Infinity"); +} + +TEST_F(AndTest, InfinityAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "Infinity"); +} + +TEST_F(AndTest, NegativeInfinityAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "-Infinity"); +} + +TEST_F(AndTest, NaNAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "NaN"); +} + +TEST_F(AndTest, NaNAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "NaN"); +} + +TEST_F(AndTest, InfinityAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "-Infinity"); +} + +TEST_F(AndTest, InfinityAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "Infinity"); +} + +TEST_F(AndTest, NegativeInfinityAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "Infinity"); +} + +TEST_F(AndTest, InfinityAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "NaN"); +} + +TEST_F(AndTest, InfinityAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "NaN"); +} + +TEST_F(AndTest, NaNAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "Infinity"); +} + +TEST_F(AndTest, NaNAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "Infinity"); +} + +TEST_F(AndTest, NegativeInfinityAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "NaN"); +} + +TEST_F(AndTest, NegativeInfinityAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "NaN"); +} + +TEST_F(AndTest, NaNAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "-Infinity"); +} + +TEST_F(AndTest, NaNAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "-Infinity"); +} + +TEST_F(AndTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "true"); +} + +TEST_F(AndTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "true"); +} + +TEST_F(AndTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", true); +} + +TEST_F(AndTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", true); +} + +TEST_F(AndTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "false"); +} + +TEST_F(AndTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "false"); +} + +TEST_F(AndTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", false); +} + +TEST_F(AndTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", false); +} + +TEST_F(AndTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "true"); +} + +TEST_F(AndTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "true"); +} + +TEST_F(AndTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", false); +} + +TEST_F(AndTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", false); +} + +TEST_F(AndTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "false"); +} + +TEST_F(AndTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "false"); +} + +TEST_F(AndTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", true); +} + +TEST_F(AndTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", true); +} + +TEST_F(AndTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "TRUE"); +} + +TEST_F(AndTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "TRUE"); +} + +TEST_F(AndTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "TRUE", true); +} + +TEST_F(AndTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "TRUE", true); +} + +TEST_F(AndTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "FALSE"); +} + +TEST_F(AndTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "FALSE"); +} + +TEST_F(AndTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "FALSE", false); +} + +TEST_F(AndTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "FALSE", false); +} + +TEST_F(AndTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "00001"); +} + +TEST_F(AndTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "00001"); +} + +TEST_F(AndTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "00001", true); +} + +TEST_F(AndTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "00001", true); +} + +TEST_F(AndTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "00000"); +} + +TEST_F(AndTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "00000"); +} + +TEST_F(AndTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "00000", true); +} + +TEST_F(AndTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "00000", true); +} + +TEST_F(AndTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "00000"); +} + +TEST_F(AndTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "00000"); +} + +TEST_F(AndTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "00000", false); +} + +TEST_F(AndTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "00000", false); +} + +TEST_F(AndTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", 1); +} + +TEST_F(AndTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", 1); +} + +TEST_F(AndTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 1, "true"); +} + +TEST_F(AndTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 1, "true"); +} + +TEST_F(AndTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", 0); +} + +TEST_F(AndTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", 0); +} + +TEST_F(AndTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 0, "true"); +} + +TEST_F(AndTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 0, "true"); +} + +TEST_F(AndTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", 0); +} + +TEST_F(AndTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", 0); +} + +TEST_F(AndTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 0, "false"); +} + +TEST_F(AndTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 0, "false"); +} + +TEST_F(AndTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", 1); +} + +TEST_F(AndTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", 1); +} + +TEST_F(AndTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, 1, "false"); +} + +TEST_F(AndTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, 1, "false"); +} + +TEST_F(AndTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", "TRUE"); +} + +TEST_F(AndTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", "TRUE"); +} + +TEST_F(AndTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "true", "FALSE"); +} + +TEST_F(AndTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "true", "FALSE"); +} + +TEST_F(AndTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", "FALSE"); +} + +TEST_F(AndTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", "FALSE"); +} + +TEST_F(AndTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "false", "TRUE"); +} + +TEST_F(AndTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "false", "TRUE"); +} + +TEST_F(AndTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "Infinity"); +} + +TEST_F(AndTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "Infinity"); +} + +TEST_F(AndTest, InfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", true); +} + +TEST_F(AndTest, InfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", true); +} + +TEST_F(AndTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "-Infinity"); +} + +TEST_F(AndTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", true); +} + +TEST_F(AndTest, NegativeInfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", true); +} + +TEST_F(AndTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, true, "NaN"); +} + +TEST_F(AndTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, true, "NaN"); +} + +TEST_F(AndTest, NaNWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", true); +} + +TEST_F(AndTest, NaNWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", true); +} + +TEST_F(AndTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "Infinity"); +} + +TEST_F(AndTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "Infinity"); +} + +TEST_F(AndTest, InfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", false); +} + +TEST_F(AndTest, InfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", false); +} + +TEST_F(AndTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "-Infinity"); +} + +TEST_F(AndTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", false); +} + +TEST_F(AndTest, NegativeInfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", false); +} + +TEST_F(AndTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, false, "NaN"); +} + +TEST_F(AndTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, false, "NaN"); +} + +TEST_F(AndTest, NaNWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", false); +} + +TEST_F(AndTest, NaNWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", false); +} + +TEST_F(AndTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "Infinity"); +} + +TEST_F(AndTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "Infinity"); +} + +TEST_F(AndTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "-Infinity"); +} + +TEST_F(AndTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "-Infinity"); +} + +TEST_F(AndTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "Infinity", "NaN"); +} + +TEST_F(AndTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "Infinity", "NaN"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "infinity", "Infinity"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "infinity", "Infinity"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "infinity", "-Infinity"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "infinity", "-Infinity"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "infinity", "NaN"); +} + +TEST_F(AndTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "infinity", "NaN"); +} + +TEST_F(AndTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "Infinity"); +} + +TEST_F(AndTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "Infinity"); +} + +TEST_F(AndTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "-Infinity"); +} + +TEST_F(AndTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-Infinity", "NaN"); +} + +TEST_F(AndTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-Infinity", "NaN"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-infinity", "Infinity"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-infinity", "Infinity"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-infinity", "-Infinity"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-infinity", "-Infinity"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "-infinity", "NaN"); +} + +TEST_F(AndTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "-infinity", "NaN"); +} + +TEST_F(AndTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "Infinity"); +} + +TEST_F(AndTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "Infinity"); +} + +TEST_F(AndTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "-Infinity"); +} + +TEST_F(AndTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "-Infinity"); +} + +TEST_F(AndTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "NaN", "NaN"); +} + +TEST_F(AndTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "NaN", "NaN"); +} + +TEST_F(AndTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "nan", "Infinity"); +} + +TEST_F(AndTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "nan", "Infinity"); +} + +TEST_F(AndTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "nan", "-Infinity"); +} + +TEST_F(AndTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "nan", "-Infinity"); +} + +TEST_F(AndTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, false, "nan", "NaN"); +} + +TEST_F(AndTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::And, true, "nan", "NaN"); +} diff --git a/test/codegen/operators/logic/not_test.cpp b/test/codegen/operators/logic/not_test.cpp new file mode 100644 index 000000000..06696b6e0 --- /dev/null +++ b/test/codegen/operators/logic/not_test.cpp @@ -0,0 +1,260 @@ +#include +#include + +#include "codegentestutils.h" + +class NotTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(NotTest, PositiveNumber) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, 10); +} + +TEST_F(NotTest, PositiveNumber_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, 10); +} + +TEST_F(NotTest, NegativeDecimal) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, -4.25); +} + +TEST_F(NotTest, NegativeDecimal_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, -4.25); +} + +TEST_F(NotTest, PositiveDecimal) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, 5.312); +} + +TEST_F(NotTest, PositiveDecimal_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, 5.312); +} + +TEST_F(NotTest, One) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, 1); +} + +TEST_F(NotTest, One_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, 1); +} + +TEST_F(NotTest, Zero) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, 0); +} + +TEST_F(NotTest, Zero_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, 0); +} + +TEST_F(NotTest, TrueBoolean) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, true); +} + +TEST_F(NotTest, TrueBoolean_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, true); +} + +TEST_F(NotTest, FalseBoolean) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, false); +} + +TEST_F(NotTest, FalseBoolean_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, false); +} + +TEST_F(NotTest, AbcString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "abc"); +} + +TEST_F(NotTest, AbcString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "abc"); +} + +TEST_F(NotTest, NumericString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "5.25"); +} + +TEST_F(NotTest, NumericString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "5.25"); +} + +TEST_F(NotTest, ZeroString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "0"); +} + +TEST_F(NotTest, ZeroString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "0"); +} + +TEST_F(NotTest, Infinity) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "Infinity"); +} + +TEST_F(NotTest, Infinity_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "Infinity"); +} + +TEST_F(NotTest, NegativeInfinity) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "-Infinity"); +} + +TEST_F(NotTest, NegativeInfinity_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "-Infinity"); +} + +TEST_F(NotTest, NaN) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "NaN"); +} + +TEST_F(NotTest, NaN_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "NaN"); +} + +TEST_F(NotTest, TrueString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "true"); +} + +TEST_F(NotTest, TrueString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "true"); +} + +TEST_F(NotTest, FalseString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "false"); +} + +TEST_F(NotTest, FalseString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "false"); +} + +TEST_F(NotTest, UppercaseTrueString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "TRUE"); +} + +TEST_F(NotTest, UppercaseTrueString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "TRUE"); +} + +TEST_F(NotTest, UppercaseFalseString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "FALSE"); +} + +TEST_F(NotTest, UppercaseFalseString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "FALSE"); +} + +TEST_F(NotTest, ZeroPaddedOne) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "00001"); +} + +TEST_F(NotTest, ZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "00001"); +} + +TEST_F(NotTest, ZeroPaddedZero) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "00000"); +} + +TEST_F(NotTest, ZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "00000"); +} + +TEST_F(NotTest, InfinityString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "Infinity"); +} + +TEST_F(NotTest, InfinityString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "Infinity"); +} + +TEST_F(NotTest, LowercaseInfinityString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "infinity"); +} + +TEST_F(NotTest, LowercaseInfinityString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "infinity"); +} + +TEST_F(NotTest, NegativeInfinityString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "-Infinity"); +} + +TEST_F(NotTest, NegativeInfinityString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "-Infinity"); +} + +TEST_F(NotTest, LowercaseNegativeInfinityString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "-infinity"); +} + +TEST_F(NotTest, LowercaseNegativeInfinityString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "-infinity"); +} + +TEST_F(NotTest, NaNString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "NaN"); +} + +TEST_F(NotTest, NaNString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "NaN"); +} + +TEST_F(NotTest, LowercaseNaNString) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, false, "nan"); +} + +TEST_F(NotTest, LowercaseNaNString_Const) +{ + ASSERT_BOOL_OP1(m_utils, CodeGenTestUtils::OpType::Not, true, "nan"); +} diff --git a/test/codegen/operators/logic/or_test.cpp b/test/codegen/operators/logic/or_test.cpp new file mode 100644 index 000000000..45b031a8f --- /dev/null +++ b/test/codegen/operators/logic/or_test.cpp @@ -0,0 +1,890 @@ +#include +#include + +#include "codegentestutils.h" + +class OrTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(OrTest, NumberWithNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 10, 8); +} + +TEST_F(OrTest, NumberWithNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 10, 8); +} + +TEST_F(OrTest, SameNegativeDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, -4.25, -4.25); +} + +TEST_F(OrTest, SameNegativeDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, -4.25, -4.25); +} + +TEST_F(OrTest, DifferentDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, -4.25, 5.312); +} + +TEST_F(OrTest, DifferentDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, -4.25, 5.312); +} + +TEST_F(OrTest, TrueAndTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, true); +} + +TEST_F(OrTest, TrueAndTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, true); +} + +TEST_F(OrTest, TrueAndFalse) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, false); +} + +TEST_F(OrTest, TrueAndFalse_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, false); +} + +TEST_F(OrTest, FalseAndTrue) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, true); +} + +TEST_F(OrTest, FalseAndTrue_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, true); +} + +TEST_F(OrTest, NumberAndTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 1, true); +} + +TEST_F(OrTest, NumberAndTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 1, true); +} + +TEST_F(OrTest, NumberAndFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 1, false); +} + +TEST_F(OrTest, NumberAndFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 1, false); +} + +TEST_F(OrTest, StringAndString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "abc", "def"); +} + +TEST_F(OrTest, StringAndString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "abc", "def"); +} + +TEST_F(OrTest, TrueStringAndTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", "true"); +} + +TEST_F(OrTest, TrueStringAndTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", "true"); +} + +TEST_F(OrTest, TrueStringAndFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", "false"); +} + +TEST_F(OrTest, TrueStringAndFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", "false"); +} + +TEST_F(OrTest, FalseStringAndTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", "true"); +} + +TEST_F(OrTest, FalseStringAndTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", "true"); +} + +TEST_F(OrTest, FalseStringAndFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", "false"); +} + +TEST_F(OrTest, FalseStringAndFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", "false"); +} + +TEST_F(OrTest, NumberAndExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 5.25, "5.25"); +} + +TEST_F(OrTest, NumberAndExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 5.25, "5.25"); +} + +TEST_F(OrTest, ExactStringAndNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "5.25", 5.25); +} + +TEST_F(OrTest, ExactStringAndNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "5.25", 5.25); +} + +TEST_F(OrTest, ZeroAndOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 0, "1"); +} + +TEST_F(OrTest, ZeroAndOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 0, "1"); +} + +TEST_F(OrTest, OneStringAndZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "1", 0); +} + +TEST_F(OrTest, OneStringAndZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "1", 0); +} + +TEST_F(OrTest, ZeroAndTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 0, "test"); +} + +TEST_F(OrTest, ZeroAndTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 0, "test"); +} + +TEST_F(OrTest, TestStringAndZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "test", 0); +} + +TEST_F(OrTest, TestStringAndZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "test", 0); +} + +TEST_F(OrTest, InfinityAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "Infinity"); +} + +TEST_F(OrTest, InfinityAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "Infinity"); +} + +TEST_F(OrTest, NegativeInfinityAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "-Infinity"); +} + +TEST_F(OrTest, NaNAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "NaN"); +} + +TEST_F(OrTest, NaNAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "NaN"); +} + +TEST_F(OrTest, InfinityAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "-Infinity"); +} + +TEST_F(OrTest, InfinityAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "Infinity"); +} + +TEST_F(OrTest, NegativeInfinityAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "Infinity"); +} + +TEST_F(OrTest, InfinityAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "NaN"); +} + +TEST_F(OrTest, InfinityAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "NaN"); +} + +TEST_F(OrTest, NaNAndInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "Infinity"); +} + +TEST_F(OrTest, NaNAndInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "Infinity"); +} + +TEST_F(OrTest, NegativeInfinityAndNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "NaN"); +} + +TEST_F(OrTest, NegativeInfinityAndNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "NaN"); +} + +TEST_F(OrTest, NaNAndNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "-Infinity"); +} + +TEST_F(OrTest, NaNAndNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "-Infinity"); +} + +TEST_F(OrTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "true"); +} + +TEST_F(OrTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "true"); +} + +TEST_F(OrTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", true); +} + +TEST_F(OrTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", true); +} + +TEST_F(OrTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "false"); +} + +TEST_F(OrTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "false"); +} + +TEST_F(OrTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", false); +} + +TEST_F(OrTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", false); +} + +TEST_F(OrTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "true"); +} + +TEST_F(OrTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "true"); +} + +TEST_F(OrTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", false); +} + +TEST_F(OrTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", false); +} + +TEST_F(OrTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "false"); +} + +TEST_F(OrTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "false"); +} + +TEST_F(OrTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", true); +} + +TEST_F(OrTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", true); +} + +TEST_F(OrTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "TRUE"); +} + +TEST_F(OrTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "TRUE"); +} + +TEST_F(OrTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "TRUE", true); +} + +TEST_F(OrTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "TRUE", true); +} + +TEST_F(OrTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "FALSE"); +} + +TEST_F(OrTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "FALSE"); +} + +TEST_F(OrTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "FALSE", false); +} + +TEST_F(OrTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "FALSE", false); +} + +TEST_F(OrTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "00001"); +} + +TEST_F(OrTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "00001"); +} + +TEST_F(OrTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "00001", true); +} + +TEST_F(OrTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "00001", true); +} + +TEST_F(OrTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "00000"); +} + +TEST_F(OrTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "00000"); +} + +TEST_F(OrTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "00000", true); +} + +TEST_F(OrTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "00000", true); +} + +TEST_F(OrTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "00000"); +} + +TEST_F(OrTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "00000"); +} + +TEST_F(OrTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "00000", false); +} + +TEST_F(OrTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "00000", false); +} + +TEST_F(OrTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", 1); +} + +TEST_F(OrTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", 1); +} + +TEST_F(OrTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 1, "true"); +} + +TEST_F(OrTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 1, "true"); +} + +TEST_F(OrTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", 0); +} + +TEST_F(OrTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", 0); +} + +TEST_F(OrTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 0, "true"); +} + +TEST_F(OrTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 0, "true"); +} + +TEST_F(OrTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", 0); +} + +TEST_F(OrTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", 0); +} + +TEST_F(OrTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 0, "false"); +} + +TEST_F(OrTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 0, "false"); +} + +TEST_F(OrTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", 1); +} + +TEST_F(OrTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", 1); +} + +TEST_F(OrTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, 1, "false"); +} + +TEST_F(OrTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, 1, "false"); +} + +TEST_F(OrTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", "TRUE"); +} + +TEST_F(OrTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", "TRUE"); +} + +TEST_F(OrTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "true", "FALSE"); +} + +TEST_F(OrTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "true", "FALSE"); +} + +TEST_F(OrTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", "FALSE"); +} + +TEST_F(OrTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", "FALSE"); +} + +TEST_F(OrTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "false", "TRUE"); +} + +TEST_F(OrTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "false", "TRUE"); +} + +TEST_F(OrTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "Infinity"); +} + +TEST_F(OrTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "Infinity"); +} + +TEST_F(OrTest, InfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", true); +} + +TEST_F(OrTest, InfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", true); +} + +TEST_F(OrTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "-Infinity"); +} + +TEST_F(OrTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", true); +} + +TEST_F(OrTest, NegativeInfinityWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", true); +} + +TEST_F(OrTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, true, "NaN"); +} + +TEST_F(OrTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, true, "NaN"); +} + +TEST_F(OrTest, NaNWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", true); +} + +TEST_F(OrTest, NaNWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", true); +} + +TEST_F(OrTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "Infinity"); +} + +TEST_F(OrTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "Infinity"); +} + +TEST_F(OrTest, InfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", false); +} + +TEST_F(OrTest, InfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", false); +} + +TEST_F(OrTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "-Infinity"); +} + +TEST_F(OrTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", false); +} + +TEST_F(OrTest, NegativeInfinityWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", false); +} + +TEST_F(OrTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, false, "NaN"); +} + +TEST_F(OrTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, false, "NaN"); +} + +TEST_F(OrTest, NaNWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", false); +} + +TEST_F(OrTest, NaNWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", false); +} + +TEST_F(OrTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "Infinity"); +} + +TEST_F(OrTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "Infinity"); +} + +TEST_F(OrTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "-Infinity"); +} + +TEST_F(OrTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "-Infinity"); +} + +TEST_F(OrTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "Infinity", "NaN"); +} + +TEST_F(OrTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "Infinity", "NaN"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "infinity", "Infinity"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "infinity", "Infinity"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "infinity", "-Infinity"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "infinity", "-Infinity"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "infinity", "NaN"); +} + +TEST_F(OrTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "infinity", "NaN"); +} + +TEST_F(OrTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "Infinity"); +} + +TEST_F(OrTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "Infinity"); +} + +TEST_F(OrTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "-Infinity"); +} + +TEST_F(OrTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-Infinity", "NaN"); +} + +TEST_F(OrTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-Infinity", "NaN"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-infinity", "Infinity"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-infinity", "Infinity"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-infinity", "-Infinity"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-infinity", "-Infinity"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "-infinity", "NaN"); +} + +TEST_F(OrTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "-infinity", "NaN"); +} + +TEST_F(OrTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "Infinity"); +} + +TEST_F(OrTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "Infinity"); +} + +TEST_F(OrTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "-Infinity"); +} + +TEST_F(OrTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "-Infinity"); +} + +TEST_F(OrTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "NaN", "NaN"); +} + +TEST_F(OrTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "NaN", "NaN"); +} + +TEST_F(OrTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "nan", "Infinity"); +} + +TEST_F(OrTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "nan", "Infinity"); +} + +TEST_F(OrTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "nan", "-Infinity"); +} + +TEST_F(OrTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "nan", "-Infinity"); +} + +TEST_F(OrTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, false, "nan", "NaN"); +} + +TEST_F(OrTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::Or, true, "nan", "NaN"); +} diff --git a/test/codegen/operators/math/abs_test.cpp b/test/codegen/operators/math/abs_test.cpp new file mode 100644 index 000000000..35cd6c971 --- /dev/null +++ b/test/codegen/operators/math/abs_test.cpp @@ -0,0 +1,116 @@ +#include +#include + +#include "codegentestutils.h" + +class AbsTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AbsTest, PositiveFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, 4.0).toDouble(), 4.0); +} + +TEST_F(AbsTest, PositiveFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, 4.0).toDouble(), 4.0); +} + +TEST_F(AbsTest, PositiveDecimal) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, 3.2).toDouble(), 3.2); +} + +TEST_F(AbsTest, PositiveDecimal_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, 3.2).toDouble(), 3.2); +} + +TEST_F(AbsTest, NegativeTwo) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, -2.0).toDouble(), 2.0); +} + +TEST_F(AbsTest, NegativeTwo_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, -2.0).toDouble(), 2.0); +} + +TEST_F(AbsTest, NegativeDecimalTwoPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, -2.5).toDouble(), 2.5); +} + +TEST_F(AbsTest, NegativeDecimalTwoPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, -2.5).toDouble(), 2.5); +} + +TEST_F(AbsTest, NegativeDecimalTwoPointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, -2.6).toDouble(), 2.6); +} + +TEST_F(AbsTest, NegativeDecimalTwoPointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, -2.6).toDouble(), 2.6); +} + +TEST_F(AbsTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, 0.0).toDouble(), 0.0); +} + +TEST_F(AbsTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, 0.0).toDouble(), 0.0); +} + +TEST_F(AbsTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, -0.0).toDouble(), 0.0); +} + +TEST_F(AbsTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, -0.0).toDouble(), 0.0); +} + +TEST_F(AbsTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, inf).toDouble(), inf); +} + +TEST_F(AbsTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, inf).toDouble(), inf); +} + +TEST_F(AbsTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, -inf).toDouble(), inf); +} + +TEST_F(AbsTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, -inf).toDouble(), inf); +} + +TEST_F(AbsTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, false, nan).toDouble(), 0); +} + +TEST_F(AbsTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Abs, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/acos_test.cpp b/test/codegen/operators/math/acos_test.cpp new file mode 100644 index 000000000..7fa5df91c --- /dev/null +++ b/test/codegen/operators/math/acos_test.cpp @@ -0,0 +1,126 @@ +#include +#include + +#include "codegentestutils.h" + +class AcosTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AcosTest, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, 1.0).toDouble(), 0.0); +} + +TEST_F(AcosTest, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, 1.0).toDouble(), 0.0); +} + +TEST_F(AcosTest, OneHalf) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, 0.5).toDouble() * 100) / 100, 60.0); +} + +TEST_F(AcosTest, OneHalf_Const) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, 0.5).toDouble() * 100) / 100, 60.0); +} + +TEST_F(AcosTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, 0.0).toDouble(), 90.0); +} + +TEST_F(AcosTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, 0.0).toDouble(), 90.0); +} + +TEST_F(AcosTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, -0.0).toDouble(), 90.0); +} + +TEST_F(AcosTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, -0.0).toDouble(), 90.0); +} + +TEST_F(AcosTest, NegativeOneHalf) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, -0.5).toDouble() * 100) / 100, 120.0); +} + +TEST_F(AcosTest, NegativeOneHalf_Const) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, -0.5).toDouble() * 100) / 100, 120.0); +} + +TEST_F(AcosTest, NegativeOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, -1.0).toDouble(), 180.0); +} + +TEST_F(AcosTest, NegativeOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, -1.0).toDouble(), 180.0); +} + +TEST_F(AcosTest, OutOfRangePositive) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, 1.1).isNaN()); +} + +TEST_F(AcosTest, OutOfRangePositive_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, 1.1).isNaN()); +} + +TEST_F(AcosTest, OutOfRangeNegative) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, -1.2).isNaN()); +} + +TEST_F(AcosTest, OutOfRangeNegative_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, -1.2).isNaN()); +} + +TEST_F(AcosTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, inf).isNaN()); +} + +TEST_F(AcosTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, inf).isNaN()); +} + +TEST_F(AcosTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, -inf).isNaN()); +} + +TEST_F(AcosTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, -inf).isNaN()); +} + +TEST_F(AcosTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, false, nan).toDouble(), 90.0); +} + +TEST_F(AcosTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Acos, true, nan).toDouble(), 90.0); +} diff --git a/test/codegen/operators/math/add_test.cpp b/test/codegen/operators/math/add_test.cpp new file mode 100644 index 000000000..7ae086e9c --- /dev/null +++ b/test/codegen/operators/math/add_test.cpp @@ -0,0 +1,130 @@ +#include +#include + +#include "codegentestutils.h" + +class AddTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AddTest, PositiveIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, 50, 25); +} + +TEST_F(AddTest, PositiveIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, 50, 25); +} + +TEST_F(AddTest, NegativeWithPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, -500, 25); +} + +TEST_F(AddTest, NegativeWithPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, -500, 25); +} + +TEST_F(AddTest, NegativeIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, -500, -25); +} + +TEST_F(AddTest, NegativeIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, -500, -25); +} + +TEST_F(AddTest, StringDecimals) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "2.54", "6.28"); +} + +TEST_F(AddTest, StringDecimals_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "2.54", "6.28"); +} + +TEST_F(AddTest, MixedDecimalAndString) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, 2.54, "-6.28"); +} + +TEST_F(AddTest, MixedDecimalAndString_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, 2.54, "-6.28"); +} + +TEST_F(AddTest, BooleanValues) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, true, true); +} + +TEST_F(AddTest, BooleanValues_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, true, true); +} + +TEST_F(AddTest, InfinityPlusInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "Infinity", "Infinity"); +} + +TEST_F(AddTest, InfinityPlusInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "Infinity", "Infinity"); +} + +TEST_F(AddTest, InfinityPlusNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "Infinity", "-Infinity"); +} + +TEST_F(AddTest, InfinityPlusNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "Infinity", "-Infinity"); +} + +TEST_F(AddTest, NegativeInfinityPlusInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "-Infinity", "Infinity"); +} + +TEST_F(AddTest, NegativeInfinityPlusInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "-Infinity", "Infinity"); +} + +TEST_F(AddTest, NegativeInfinityPlusNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "-Infinity", "-Infinity"); +} + +TEST_F(AddTest, NegativeInfinityPlusNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "-Infinity", "-Infinity"); +} + +TEST_F(AddTest, NumberPlusNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, 1, "NaN"); +} + +TEST_F(AddTest, NumberPlusNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, 1, "NaN"); +} + +TEST_F(AddTest, NaNPlusNumber) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, false, "NaN", 1); +} + +TEST_F(AddTest, NaNPlusNumber_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Add, true, "NaN", 1); +} diff --git a/test/codegen/operators/math/asin_test.cpp b/test/codegen/operators/math/asin_test.cpp new file mode 100644 index 000000000..94b9d554c --- /dev/null +++ b/test/codegen/operators/math/asin_test.cpp @@ -0,0 +1,126 @@ +#include +#include + +#include "codegentestutils.h" + +class AsinTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AsinTest, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, 1.0).toDouble(), 90.0); +} + +TEST_F(AsinTest, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, 1.0).toDouble(), 90.0); +} + +TEST_F(AsinTest, OneHalf) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, 0.5).toDouble() * 100) / 100, 30.0); +} + +TEST_F(AsinTest, OneHalf_Const) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, 0.5).toDouble() * 100) / 100, 30.0); +} + +TEST_F(AsinTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, 0.0).toDouble(), 0.0); +} + +TEST_F(AsinTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, 0.0).toDouble(), 0.0); +} + +TEST_F(AsinTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, -0.0).toDouble(), 0.0); +} + +TEST_F(AsinTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, -0.0).toDouble(), 0.0); +} + +TEST_F(AsinTest, NegativeOneHalf) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, -0.5).toDouble() * 100) / 100, -30.0); +} + +TEST_F(AsinTest, NegativeOneHalf_Const) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, -0.5).toDouble() * 100) / 100, -30.0); +} + +TEST_F(AsinTest, NegativeOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, -1.0).toDouble(), -90.0); +} + +TEST_F(AsinTest, NegativeOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, -1.0).toDouble(), -90.0); +} + +TEST_F(AsinTest, OutOfRangePositive) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, 1.1).isNaN()); +} + +TEST_F(AsinTest, OutOfRangePositive_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, 1.1).isNaN()); +} + +TEST_F(AsinTest, OutOfRangeNegative) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, -1.2).isNaN()); +} + +TEST_F(AsinTest, OutOfRangeNegative_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, -1.2).isNaN()); +} + +TEST_F(AsinTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, inf).isNaN()); +} + +TEST_F(AsinTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, inf).isNaN()); +} + +TEST_F(AsinTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, -inf).isNaN()); +} + +TEST_F(AsinTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, -inf).isNaN()); +} + +TEST_F(AsinTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, false, nan).toDouble(), 0.0); +} + +TEST_F(AsinTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Asin, true, nan).toDouble(), 0.0); +} diff --git a/test/codegen/operators/math/atan_test.cpp b/test/codegen/operators/math/atan_test.cpp new file mode 100644 index 000000000..96c2c7329 --- /dev/null +++ b/test/codegen/operators/math/atan_test.cpp @@ -0,0 +1,86 @@ +#include +#include + +#include "codegentestutils.h" + +class AtanTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(AtanTest, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, 1.0).toDouble(), 45.0); +} + +TEST_F(AtanTest, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, 1.0).toDouble(), 45.0); +} + +TEST_F(AtanTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, 0.0).toDouble(), 0.0); +} + +TEST_F(AtanTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, 0.0).toDouble(), 0.0); +} + +TEST_F(AtanTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, -0.0).toDouble(), -0.0); +} + +TEST_F(AtanTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, -0.0).toDouble(), -0.0); +} + +TEST_F(AtanTest, NegativeOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, -1.0).toDouble(), -45.0); +} + +TEST_F(AtanTest, NegativeOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, -1.0).toDouble(), -45.0); +} + +TEST_F(AtanTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, inf).toDouble(), 90.0); +} + +TEST_F(AtanTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, inf).toDouble(), 90.0); +} + +TEST_F(AtanTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, -inf).toDouble(), -90.0); +} + +TEST_F(AtanTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, -inf).toDouble(), -90.0); +} + +TEST_F(AtanTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, false, nan).toDouble(), 0.0); +} + +TEST_F(AtanTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Atan, true, nan).toDouble(), 0.0); +} diff --git a/test/codegen/operators/math/ceil_test.cpp b/test/codegen/operators/math/ceil_test.cpp new file mode 100644 index 000000000..975095ad7 --- /dev/null +++ b/test/codegen/operators/math/ceil_test.cpp @@ -0,0 +1,176 @@ +#include +#include + +#include "codegentestutils.h" + +class CeilTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(CeilTest, EightPointZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 8.0).toDouble(), 8.0); +} + +TEST_F(CeilTest, EightPointZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 8.0).toDouble(), 8.0); +} + +TEST_F(CeilTest, ThreePointTwo) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 3.2).toDouble(), 4.0); +} + +TEST_F(CeilTest, ThreePointTwo_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 3.2).toDouble(), 4.0); +} + +TEST_F(CeilTest, ThreePointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 3.5).toDouble(), 4.0); +} + +TEST_F(CeilTest, ThreePointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 3.5).toDouble(), 4.0); +} + +TEST_F(CeilTest, ThreePointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 3.6).toDouble(), 4.0); +} + +TEST_F(CeilTest, ThreePointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 3.6).toDouble(), 4.0); +} + +TEST_F(CeilTest, ZeroPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 0.4).toDouble(), 1.0); +} + +TEST_F(CeilTest, ZeroPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 0.4).toDouble(), 1.0); +} + +TEST_F(CeilTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, 0.0).toDouble(), 0.0); +} + +TEST_F(CeilTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, 0.0).toDouble(), 0.0); +} + +TEST_F(CeilTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -0.0).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -0.0).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeTwoPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -2.4).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeTwoPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -2.4).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeTwoPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -2.5).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeTwoPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -2.5).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeTwoPointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -2.6).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeTwoPointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -2.6).toDouble(), -2.0); +} + +TEST_F(CeilTest, NegativeZeroPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -0.4).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZeroPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -0.4).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZeroPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -0.5).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZeroPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -0.5).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZeroPointFiftyOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -0.51).toDouble(), -0.0); +} + +TEST_F(CeilTest, NegativeZeroPointFiftyOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -0.51).toDouble(), -0.0); +} + +TEST_F(CeilTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, inf).toDouble(), inf); +} + +TEST_F(CeilTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, inf).toDouble(), inf); +} + +TEST_F(CeilTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, -inf).toDouble(), -inf); +} + +TEST_F(CeilTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, -inf).toDouble(), -inf); +} + +TEST_F(CeilTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, false, nan).toDouble(), 0); +} + +TEST_F(CeilTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ceil, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/cos_test.cpp b/test/codegen/operators/math/cos_test.cpp new file mode 100644 index 000000000..1b1b6940d --- /dev/null +++ b/test/codegen/operators/math/cos_test.cpp @@ -0,0 +1,136 @@ +#include +#include + +#include "codegentestutils.h" + +class CosTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(CosTest, SixtyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 60.0).toDouble(), 0.5); +} + +TEST_F(CosTest, SixtyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 60.0).toDouble(), 0.5); +} + +TEST_F(CosTest, NinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 90.0).toDouble(), 0.0); +} + +TEST_F(CosTest, NinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 90.0).toDouble(), 0.0); +} + +TEST_F(CosTest, SixHundredDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 600.0).toDouble(), -0.5); +} + +TEST_F(CosTest, SixHundredDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 600.0).toDouble(), -0.5); +} + +TEST_F(CosTest, AlmostNinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 89.9999999971352).toDouble(), 1e-10); +} + +TEST_F(CosTest, AlmostNinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 89.9999999971352).toDouble(), 1e-10); +} + +TEST_F(CosTest, VeryCloseToNinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 89.999999999).toDouble(), 0.0); +} + +TEST_F(CosTest, VeryCloseToNinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 89.999999999).toDouble(), 0.0); +} + +TEST_F(CosTest, NegativeSixtyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, -60.0).toDouble(), 0.5); +} + +TEST_F(CosTest, NegativeSixtyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, -60.0).toDouble(), 0.5); +} + +TEST_F(CosTest, NegativeNinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, -90.0).toDouble(), 0.0); +} + +TEST_F(CosTest, NegativeNinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, -90.0).toDouble(), 0.0); +} + +TEST_F(CosTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, 0.0).toDouble(), 1.0); +} + +TEST_F(CosTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, 0.0).toDouble(), 1.0); +} + +TEST_F(CosTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, -0.0).toDouble(), 1.0); +} + +TEST_F(CosTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, -0.0).toDouble(), 1.0); +} + +TEST_F(CosTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, inf).isNaN()); +} + +TEST_F(CosTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, inf).isNaN()); +} + +TEST_F(CosTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, -inf).isNaN()); +} + +TEST_F(CosTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, -inf).isNaN()); +} + +TEST_F(CosTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, false, nan).toDouble(), 1.0); +} + +TEST_F(CosTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Cos, true, nan).toDouble(), 1.0); +} diff --git a/test/codegen/operators/math/divide_test.cpp b/test/codegen/operators/math/divide_test.cpp new file mode 100644 index 000000000..7c35e157c --- /dev/null +++ b/test/codegen/operators/math/divide_test.cpp @@ -0,0 +1,270 @@ +#include +#include + +#include "codegentestutils.h" + +class DivideTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(DivideTest, PositiveIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 50, 2); +} + +TEST_F(DivideTest, PositiveIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 50, 2); +} + +TEST_F(DivideTest, NegativeWithPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, -500, 25); +} + +TEST_F(DivideTest, NegativeWithPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, -500, 25); +} + +TEST_F(DivideTest, StringNegativeWithNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-500", -25); +} + +TEST_F(DivideTest, StringNegativeWithNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-500", -25); +} + +TEST_F(DivideTest, StringDecimals) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "3.5", "2.5"); +} + +TEST_F(DivideTest, StringDecimals_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "3.5", "2.5"); +} + +TEST_F(DivideTest, BooleanValues) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, true, true); +} + +TEST_F(DivideTest, BooleanValues_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, true, true); +} + +TEST_F(DivideTest, InfinityDividedByInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "Infinity", "Infinity"); +} + +TEST_F(DivideTest, InfinityDividedByInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "Infinity", "Infinity"); +} + +TEST_F(DivideTest, InfinityDividedByZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "Infinity", 0); +} + +TEST_F(DivideTest, InfinityDividedByZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "Infinity", 0); +} + +TEST_F(DivideTest, InfinityDividedByPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "Infinity", 2); +} + +TEST_F(DivideTest, InfinityDividedByPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "Infinity", 2); +} + +TEST_F(DivideTest, InfinityDividedByNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "Infinity", -2); +} + +TEST_F(DivideTest, InfinityDividedByNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "Infinity", -2); +} + +TEST_F(DivideTest, InfinityDividedByNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "Infinity", "-Infinity"); +} + +TEST_F(DivideTest, InfinityDividedByNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "Infinity", "-Infinity"); +} + +TEST_F(DivideTest, NegativeInfinityDividedByInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-Infinity", "Infinity"); +} + +TEST_F(DivideTest, NegativeInfinityDividedByInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-Infinity", "Infinity"); +} + +TEST_F(DivideTest, NegativeInfinityDividedByZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-Infinity", 0); +} + +TEST_F(DivideTest, NegativeInfinityDividedByZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-Infinity", 0); +} + +TEST_F(DivideTest, NegativeInfinityDividedByPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-Infinity", 2); +} + +TEST_F(DivideTest, NegativeInfinityDividedByPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-Infinity", 2); +} + +TEST_F(DivideTest, NegativeInfinityDividedByNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-Infinity", -2); +} + +TEST_F(DivideTest, NegativeInfinityDividedByNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-Infinity", -2); +} + +TEST_F(DivideTest, NegativeInfinityDividedByNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "-Infinity", "-Infinity"); +} + +TEST_F(DivideTest, NegativeInfinityDividedByNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "-Infinity", "-Infinity"); +} + +TEST_F(DivideTest, ZeroDividedByInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 0, "Infinity"); +} + +TEST_F(DivideTest, ZeroDividedByInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 0, "Infinity"); +} + +TEST_F(DivideTest, PositiveDividedByInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 2, "Infinity"); +} + +TEST_F(DivideTest, PositiveDividedByInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 2, "Infinity"); +} + +TEST_F(DivideTest, NegativeDividedByInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, -2, "Infinity"); +} + +TEST_F(DivideTest, NegativeDividedByInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, -2, "Infinity"); +} + +TEST_F(DivideTest, ZeroDividedByNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 0, "-Infinity"); +} + +TEST_F(DivideTest, ZeroDividedByNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 0, "-Infinity"); +} + +TEST_F(DivideTest, PositiveDividedByNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 2, "-Infinity"); +} + +TEST_F(DivideTest, PositiveDividedByNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 2, "-Infinity"); +} + +TEST_F(DivideTest, NegativeDividedByNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, -2, "-Infinity"); +} + +TEST_F(DivideTest, NegativeDividedByNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, -2, "-Infinity"); +} + +TEST_F(DivideTest, NumberDividedByNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 1, "NaN"); +} + +TEST_F(DivideTest, NumberDividedByNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 1, "NaN"); +} + +TEST_F(DivideTest, NaNDividedByNumber) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, "NaN", 1); +} + +TEST_F(DivideTest, NaNDividedByNumber_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, "NaN", 1); +} + +TEST_F(DivideTest, PositiveDividedByZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 5, 0); +} + +TEST_F(DivideTest, PositiveDividedByZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 5, 0); +} + +TEST_F(DivideTest, NegativeDividedByZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, -5, 0); +} + +TEST_F(DivideTest, NegativeDividedByZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, -5, 0); +} + +TEST_F(DivideTest, ZeroDividedByZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, false, 0, 0); +} + +TEST_F(DivideTest, ZeroDividedByZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Div, true, 0, 0); +} diff --git a/test/codegen/operators/math/exp10_test.cpp b/test/codegen/operators/math/exp10_test.cpp new file mode 100644 index 000000000..aab35af25 --- /dev/null +++ b/test/codegen/operators/math/exp10_test.cpp @@ -0,0 +1,106 @@ +#include +#include + +#include "codegentestutils.h" + +class Exp10Test : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(Exp10Test, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, 1.0).toDouble(), 10.0); +} + +TEST_F(Exp10Test, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, 1.0).toDouble(), 10.0); +} + +TEST_F(Exp10Test, Three) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, 3.0).toDouble(), 1000.0); +} + +TEST_F(Exp10Test, Three_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, 3.0).toDouble(), 1000.0); +} + +TEST_F(Exp10Test, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, 0.0).toDouble(), 1.0); +} + +TEST_F(Exp10Test, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, 0.0).toDouble(), 1.0); +} + +TEST_F(Exp10Test, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, -0.0).toDouble(), 1.0); +} + +TEST_F(Exp10Test, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, -0.0).toDouble(), 1.0); +} + +TEST_F(Exp10Test, NegativeOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, -1.0).toDouble(), 0.1); +} + +TEST_F(Exp10Test, NegativeOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, -1.0).toDouble(), 0.1); +} + +TEST_F(Exp10Test, NegativeFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, -5.0).toDouble(), 0.00001); +} + +TEST_F(Exp10Test, NegativeFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, -5.0).toDouble(), 0.00001); +} + +TEST_F(Exp10Test, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, inf).toDouble(), inf); +} + +TEST_F(Exp10Test, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, inf).toDouble(), inf); +} + +TEST_F(Exp10Test, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, -inf).toDouble(), 0.0); +} + +TEST_F(Exp10Test, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, -inf).toDouble(), 0.0); +} + +TEST_F(Exp10Test, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, false, nan).toDouble(), 1.0); +} + +TEST_F(Exp10Test, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp10, true, nan).toDouble(), 1.0); +} diff --git a/test/codegen/operators/math/exp_test.cpp b/test/codegen/operators/math/exp_test.cpp new file mode 100644 index 000000000..cde99c0d3 --- /dev/null +++ b/test/codegen/operators/math/exp_test.cpp @@ -0,0 +1,96 @@ +#include +#include + +#include "codegentestutils.h" + +class ExpTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(ExpTest, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, 1.0).toDouble(), std::exp(1.0)); +} + +TEST_F(ExpTest, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, 1.0).toDouble(), std::exp(1.0)); +} + +TEST_F(ExpTest, ZeroPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, 0.5).toDouble(), std::exp(0.5)); +} + +TEST_F(ExpTest, ZeroPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, 0.5).toDouble(), std::exp(0.5)); +} + +TEST_F(ExpTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, 0.0).toDouble(), 1.0); +} + +TEST_F(ExpTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, 0.0).toDouble(), 1.0); +} + +TEST_F(ExpTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, -0.0).toDouble(), 1.0); +} + +TEST_F(ExpTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, -0.0).toDouble(), 1.0); +} + +TEST_F(ExpTest, NegativeZeroPointSeven) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, -0.7).toDouble(), std::exp(-0.7)); +} + +TEST_F(ExpTest, NegativeZeroPointSeven_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, -0.7).toDouble(), std::exp(-0.7)); +} + +TEST_F(ExpTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, inf).toDouble(), inf); +} + +TEST_F(ExpTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, inf).toDouble(), inf); +} + +TEST_F(ExpTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, -inf).toDouble(), 0.0); +} + +TEST_F(ExpTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, -inf).toDouble(), 0.0); +} + +TEST_F(ExpTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, false, nan).toDouble(), 1.0); +} + +TEST_F(ExpTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Exp, true, nan).toDouble(), 1.0); +} diff --git a/test/codegen/operators/math/floor_test.cpp b/test/codegen/operators/math/floor_test.cpp new file mode 100644 index 000000000..1b8142112 --- /dev/null +++ b/test/codegen/operators/math/floor_test.cpp @@ -0,0 +1,166 @@ +#include +#include + +#include "codegentestutils.h" + +class FloorTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(FloorTest, FourPointZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, 4.0).toDouble(), 4.0); +} + +TEST_F(FloorTest, FourPointZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, 4.0).toDouble(), 4.0); +} + +TEST_F(FloorTest, ThreePointTwo) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, 3.2).toDouble(), 3.0); +} + +TEST_F(FloorTest, ThreePointTwo_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, 3.2).toDouble(), 3.0); +} + +TEST_F(FloorTest, ThreePointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, 3.5).toDouble(), 3.0); +} + +TEST_F(FloorTest, ThreePointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, 3.5).toDouble(), 3.0); +} + +TEST_F(FloorTest, ThreePointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, 3.6).toDouble(), 3.0); +} + +TEST_F(FloorTest, ThreePointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, 3.6).toDouble(), 3.0); +} + +TEST_F(FloorTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, 0.0).toDouble(), 0.0); +} + +TEST_F(FloorTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, 0.0).toDouble(), 0.0); +} + +TEST_F(FloorTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -0.0).toDouble(), -0.0); +} + +TEST_F(FloorTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -0.0).toDouble(), -0.0); +} + +TEST_F(FloorTest, NegativeTwoPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -2.4).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeTwoPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -2.4).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeTwoPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -2.5).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeTwoPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -2.5).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeTwoPointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -2.6).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeTwoPointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -2.6).toDouble(), -3.0); +} + +TEST_F(FloorTest, NegativeZeroPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -0.4).toDouble(), -1.0); +} + +TEST_F(FloorTest, NegativeZeroPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -0.4).toDouble(), -1.0); +} + +TEST_F(FloorTest, NegativeZeroPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -0.5).toDouble(), -1.0); +} + +TEST_F(FloorTest, NegativeZeroPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -0.5).toDouble(), -1.0); +} + +TEST_F(FloorTest, NegativeZeroPointFiftyOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -0.51).toDouble(), -1.0); +} + +TEST_F(FloorTest, NegativeZeroPointFiftyOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -0.51).toDouble(), -1.0); +} + +TEST_F(FloorTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, inf).toDouble(), inf); +} + +TEST_F(FloorTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, inf).toDouble(), inf); +} + +TEST_F(FloorTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, -inf).toDouble(), -inf); +} + +TEST_F(FloorTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, -inf).toDouble(), -inf); +} + +TEST_F(FloorTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, false, nan).toDouble(), 0); +} + +TEST_F(FloorTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Floor, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/ln_test.cpp b/test/codegen/operators/math/ln_test.cpp new file mode 100644 index 000000000..090a100a3 --- /dev/null +++ b/test/codegen/operators/math/ln_test.cpp @@ -0,0 +1,122 @@ +#include +#include + +#include "codegentestutils.h" + +class LnTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(LnTest, ExpOfOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, std::exp(1.0)).toDouble(), 1.0); +} + +TEST_F(LnTest, ExpOfOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, std::exp(1.0)).toDouble(), 1.0); +} + +TEST_F(LnTest, ExpOfTwo) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, std::exp(2.0)).toDouble(), 2.0); +} + +TEST_F(LnTest, ExpOfTwo_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, std::exp(2.0)).toDouble(), 2.0); +} + +TEST_F(LnTest, ExpOfZeroPointThree) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, std::exp(0.3)).toDouble() * 100) / 100, 0.3); +} + +TEST_F(LnTest, ExpOfZeroPointThree_Const) +{ + ASSERT_EQ(std::round(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, std::exp(0.3)).toDouble() * 100) / 100, 0.3); +} + +TEST_F(LnTest, One) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, 1.0).toDouble(), 0.0); +} + +TEST_F(LnTest, One_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, 1.0).toDouble(), 0.0); +} + +TEST_F(LnTest, PositiveZero) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, 0.0).toDouble(), -inf); +} + +TEST_F(LnTest, PositiveZero_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, 0.0).toDouble(), -inf); +} + +TEST_F(LnTest, NegativeZero) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, -0.0).toDouble(), -inf); +} + +TEST_F(LnTest, NegativeZero_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, -0.0).toDouble(), -inf); +} + +TEST_F(LnTest, NegativeNumber) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, -0.7).isNaN()); +} + +TEST_F(LnTest, NegativeNumber_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, -0.7).isNaN()); +} + +TEST_F(LnTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, inf).toDouble(), inf); +} + +TEST_F(LnTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, inf).toDouble(), inf); +} + +TEST_F(LnTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, -inf).isNaN()); +} + +TEST_F(LnTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, -inf).isNaN()); +} + +TEST_F(LnTest, NaN) +{ + static const double inf = std::numeric_limits::infinity(); + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, false, nan).toDouble(), -inf); +} + +TEST_F(LnTest, NaN_Const) +{ + static const double inf = std::numeric_limits::infinity(); + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Ln, true, nan).toDouble(), -inf); +} diff --git a/test/codegen/operators/math/log10_test.cpp b/test/codegen/operators/math/log10_test.cpp new file mode 100644 index 000000000..9ec75d08e --- /dev/null +++ b/test/codegen/operators/math/log10_test.cpp @@ -0,0 +1,112 @@ +#include +#include + +#include "codegentestutils.h" + +class Log10Test : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(Log10Test, Ten) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, 10.0).toDouble(), 1.0); +} + +TEST_F(Log10Test, Ten_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, 10.0).toDouble(), 1.0); +} + +TEST_F(Log10Test, OneThousand) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, 1000.0).toDouble(), 3.0); +} + +TEST_F(Log10Test, OneThousand_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, 1000.0).toDouble(), 3.0); +} + +TEST_F(Log10Test, ZeroPointZeroOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, 0.01).toDouble(), -2.0); +} + +TEST_F(Log10Test, ZeroPointZeroOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, 0.01).toDouble(), -2.0); +} + +TEST_F(Log10Test, PositiveZero) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, 0.0).toDouble(), -inf); +} + +TEST_F(Log10Test, PositiveZero_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, 0.0).toDouble(), -inf); +} + +TEST_F(Log10Test, NegativeZero) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, -0.0).toDouble(), -inf); +} + +TEST_F(Log10Test, NegativeZero_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, -0.0).toDouble(), -inf); +} + +TEST_F(Log10Test, NegativeNumber) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, -0.7).isNaN()); +} + +TEST_F(Log10Test, NegativeNumber_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, -0.7).isNaN()); +} + +TEST_F(Log10Test, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, inf).toDouble(), inf); +} + +TEST_F(Log10Test, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, inf).toDouble(), inf); +} + +TEST_F(Log10Test, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, -inf).isNaN()); +} + +TEST_F(Log10Test, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, -inf).isNaN()); +} + +TEST_F(Log10Test, NaN) +{ + static const double inf = std::numeric_limits::infinity(); + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, false, nan).toDouble(), -inf); +} + +TEST_F(Log10Test, NaN_Const) +{ + static const double inf = std::numeric_limits::infinity(); + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Log10, true, nan).toDouble(), -inf); +} diff --git a/test/codegen/operators/math/mod_test.cpp b/test/codegen/operators/math/mod_test.cpp new file mode 100644 index 000000000..0b5e6e830 --- /dev/null +++ b/test/codegen/operators/math/mod_test.cpp @@ -0,0 +1,300 @@ +#include +#include + +#include "codegentestutils.h" + +class ModTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(ModTest, FourModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 4, 3); +} + +TEST_F(ModTest, FourModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 4, 3); +} + +TEST_F(ModTest, ThreeModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 3, 3); +} + +TEST_F(ModTest, ThreeModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 3, 3); +} + +TEST_F(ModTest, TwoModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 2, 3); +} + +TEST_F(ModTest, TwoModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 2, 3); +} + +TEST_F(ModTest, OneModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 1, 3); +} + +TEST_F(ModTest, OneModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 1, 3); +} + +TEST_F(ModTest, ZeroModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 0, 3); +} + +TEST_F(ModTest, ZeroModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 0, 3); +} + +TEST_F(ModTest, NegativeOneModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -1, 3); +} + +TEST_F(ModTest, NegativeOneModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -1, 3); +} + +TEST_F(ModTest, NegativeTwoModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -2, 3); +} + +TEST_F(ModTest, NegativeTwoModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -2, 3); +} + +TEST_F(ModTest, NegativeThreeModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -3, 3); +} + +TEST_F(ModTest, NegativeThreeModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -3, 3); +} + +TEST_F(ModTest, NegativeFourModThree) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -4, 3); +} + +TEST_F(ModTest, NegativeFourModThree_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -4, 3); +} + +TEST_F(ModTest, DecimalModTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 4.75, 2); +} + +TEST_F(ModTest, DecimalModTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 4.75, 2); +} + +TEST_F(ModTest, NegativeDecimalModTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -4.75, 2); +} + +TEST_F(ModTest, NegativeDecimalModTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -4.75, 2); +} + +TEST_F(ModTest, NegativeDecimalModNegativeTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -4.75, -2); +} + +TEST_F(ModTest, NegativeDecimalModNegativeTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -4.75, -2); +} + +TEST_F(ModTest, DecimalModNegativeTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 4.75, -2); +} + +TEST_F(ModTest, DecimalModNegativeTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 4.75, -2); +} + +TEST_F(ModTest, FiveModZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 5, 0); +} + +TEST_F(ModTest, FiveModZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 5, 0); +} + +TEST_F(ModTest, NegativeFiveModZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -5, 0); +} + +TEST_F(ModTest, NegativeFiveModZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -5, 0); +} + +TEST_F(ModTest, PositiveDecimalModZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 5.8, 0); +} + +TEST_F(ModTest, PositiveDecimalModZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 5.8, 0); +} + +TEST_F(ModTest, NegativeDecimalModZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -5.8, 0); +} + +TEST_F(ModTest, NegativeDecimalModZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -5.8, 0); +} + +TEST_F(ModTest, NegativeDecimalModInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -2.5, "Infinity"); +} + +TEST_F(ModTest, NegativeDecimalModInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -2.5, "Infinity"); +} + +TEST_F(ModTest, NegativeDecimalModNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -1.2, "-Infinity"); +} + +TEST_F(ModTest, NegativeDecimalModNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -1.2, "-Infinity"); +} + +TEST_F(ModTest, PositiveDecimalModInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 2.5, "Infinity"); +} + +TEST_F(ModTest, PositiveDecimalModInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 2.5, "Infinity"); +} + +TEST_F(ModTest, PositiveDecimalModNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 1.2, "-Infinity"); +} + +TEST_F(ModTest, PositiveDecimalModNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 1.2, "-Infinity"); +} + +TEST_F(ModTest, InfinityModTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "Infinity", 2); +} + +TEST_F(ModTest, InfinityModTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "Infinity", 2); +} + +TEST_F(ModTest, NegativeInfinityModTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "-Infinity", 2); +} + +TEST_F(ModTest, NegativeInfinityModTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "-Infinity", 2); +} + +TEST_F(ModTest, InfinityModNegativeTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "Infinity", -2); +} + +TEST_F(ModTest, InfinityModNegativeTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "Infinity", -2); +} + +TEST_F(ModTest, NegativeInfinityModNegativeTwo) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "-Infinity", -2); +} + +TEST_F(ModTest, NegativeInfinityModNegativeTwo_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "-Infinity", -2); +} + +TEST_F(ModTest, ThreeModNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, 3, "NaN"); +} + +TEST_F(ModTest, ThreeModNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, 3, "NaN"); +} + +TEST_F(ModTest, NegativeThreeModNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, -3, "NaN"); +} + +TEST_F(ModTest, NegativeThreeModNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, -3, "NaN"); +} + +TEST_F(ModTest, NaNModFive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "NaN", 5); +} + +TEST_F(ModTest, NaNModFive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "NaN", 5); +} + +TEST_F(ModTest, NaNModNegativeFive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, false, "NaN", -5); +} + +TEST_F(ModTest, NaNModNegativeFive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mod, true, "NaN", -5); +} diff --git a/test/codegen/operators/math/multiply_test.cpp b/test/codegen/operators/math/multiply_test.cpp new file mode 100644 index 000000000..b58652560 --- /dev/null +++ b/test/codegen/operators/math/multiply_test.cpp @@ -0,0 +1,180 @@ +#include +#include + +#include "codegentestutils.h" + +class MultiplyTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(MultiplyTest, PositiveIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, 50, 2); +} + +TEST_F(MultiplyTest, PositiveIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, 50, 2); +} + +TEST_F(MultiplyTest, NegativeWithPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, -500, 25); +} + +TEST_F(MultiplyTest, NegativeWithPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, -500, 25); +} + +TEST_F(MultiplyTest, StringNegativeWithNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-500", -25); +} + +TEST_F(MultiplyTest, StringNegativeWithNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-500", -25); +} + +TEST_F(MultiplyTest, StringDecimals) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "2.54", "6.28"); +} + +TEST_F(MultiplyTest, StringDecimals_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "2.54", "6.28"); +} + +TEST_F(MultiplyTest, BooleanValues) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, true, true); +} + +TEST_F(MultiplyTest, BooleanValues_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, true, true); +} + +TEST_F(MultiplyTest, InfinityTimesInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "Infinity", "Infinity"); +} + +TEST_F(MultiplyTest, InfinityTimesInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "Infinity", "Infinity"); +} + +TEST_F(MultiplyTest, InfinityTimesZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "Infinity", 0); +} + +TEST_F(MultiplyTest, InfinityTimesZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "Infinity", 0); +} + +TEST_F(MultiplyTest, InfinityTimesPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "Infinity", 2); +} + +TEST_F(MultiplyTest, InfinityTimesPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "Infinity", 2); +} + +TEST_F(MultiplyTest, InfinityTimesNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "Infinity", -2); +} + +TEST_F(MultiplyTest, InfinityTimesNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "Infinity", -2); +} + +TEST_F(MultiplyTest, InfinityTimesNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "Infinity", "-Infinity"); +} + +TEST_F(MultiplyTest, InfinityTimesNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "Infinity", "-Infinity"); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-Infinity", "Infinity"); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-Infinity", "Infinity"); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesZero) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-Infinity", 0); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesZero_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-Infinity", 0); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-Infinity", 2); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-Infinity", 2); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesNegative) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-Infinity", -2); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesNegative_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-Infinity", -2); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "-Infinity", "-Infinity"); +} + +TEST_F(MultiplyTest, NegativeInfinityTimesNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "-Infinity", "-Infinity"); +} + +TEST_F(MultiplyTest, NumberTimesNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, 1, "NaN"); +} + +TEST_F(MultiplyTest, NumberTimesNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, 1, "NaN"); +} + +TEST_F(MultiplyTest, NaNTimesNumber) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, false, "NaN", 1); +} + +TEST_F(MultiplyTest, NaNTimesNumber_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Mul, true, "NaN", 1); +} diff --git a/test/codegen/operators/math/random_int_test.cpp b/test/codegen/operators/math/random_int_test.cpp new file mode 100644 index 000000000..347698f2d --- /dev/null +++ b/test/codegen/operators/math/random_int_test.cpp @@ -0,0 +1,134 @@ +#include +#include + +#include "codegentestutils.h" + +using ::testing::Return; + +class RandomIntTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(RandomIntTest, IntegerRange) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-18)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, -45, 12); +} + +TEST_F(RandomIntTest, IntegerRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-18)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, -45, 12); +} + +TEST_F(RandomIntTest, DoubleAsInteger) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, -45.0, 12.0); +} + +TEST_F(RandomIntTest, DoubleAsInteger_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, -45.0, 12.0); +} + +TEST_F(RandomIntTest, TruncatedDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randint(12, 6)).Times(2).WillRepeatedly(Return(3)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, 12, 6.05); +} + +TEST_F(RandomIntTest, TruncatedDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(12, 6)).Times(2).WillRepeatedly(Return(3)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, 12, 6.05); +} + +TEST_F(RandomIntTest, NegativeDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randint(-78, -45)).Times(2).WillRepeatedly(Return(-59)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, -78.686, -45); +} + +TEST_F(RandomIntTest, NegativeDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-78, -45)).Times(2).WillRepeatedly(Return(-59)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, -78.686, -45); +} + +TEST_F(RandomIntTest, StringIntegerRange) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, "-45", "12"); +} + +TEST_F(RandomIntTest, StringIntegerRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, "-45", "12"); +} + +TEST_F(RandomIntTest, StringDoubleToInteger) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, "-45.0", "12"); +} + +TEST_F(RandomIntTest, StringDoubleToInteger_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, "-45.0", "12"); +} + +TEST_F(RandomIntTest, StringIntegerToDouble) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-15)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, "-45", "12.0"); +} + +TEST_F(RandomIntTest, StringIntegerToDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-15)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, "-45", "12.0"); +} + +TEST_F(RandomIntTest, BooleanRange) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 1)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, false, true); +} + +TEST_F(RandomIntTest, BooleanRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 1)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, false, true); +} + +TEST_F(RandomIntTest, BooleanWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint(1, 5)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, true, 5); +} + +TEST_F(RandomIntTest, BooleanWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(1, 5)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, true, 5); +} + +TEST_F(RandomIntTest, NumberWithBoolean) +{ + EXPECT_CALL(m_utils.rng(), randint(8, 0)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, false, 8, false); +} + +TEST_F(RandomIntTest, NumberWithBoolean_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(8, 0)).Times(2).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::RandomInt, true, 8, false); +} + +// NOTE: Infinity, -Infinity and NaN behavior is undefined diff --git a/test/codegen/operators/math/random_test.cpp b/test/codegen/operators/math/random_test.cpp new file mode 100644 index 000000000..c0600ca0a --- /dev/null +++ b/test/codegen/operators/math/random_test.cpp @@ -0,0 +1,444 @@ +#include +#include + +#include "codegentestutils.h" + +using ::testing::Return; + +class RandomTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(RandomTest, IntegerRange) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(-18)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -45, 12); +} + +TEST_F(RandomTest, IntegerRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(-18)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -45, 12); +} + +TEST_F(RandomTest, DoubleAsInteger) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -45.0, 12.0); +} + +TEST_F(RandomTest, DoubleAsInteger_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -45.0, 12.0); +} + +TEST_F(RandomTest, DoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(12, 6.05)).WillRepeatedly(Return(3.486789)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 12, 6.05); +} + +TEST_F(RandomTest, DoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(12, 6.05)).WillRepeatedly(Return(3.486789)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 12, 6.05); +} + +TEST_F(RandomTest, NegativeDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-78.686, -45)).WillRepeatedly(Return(-59.468873)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -78.686, -45); +} + +TEST_F(RandomTest, NegativeDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-78.686, -45)).WillRepeatedly(Return(-59.468873)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -78.686, -45); +} + +TEST_F(RandomTest, ReversedDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(-28.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 6.05, -78.686); +} + +TEST_F(RandomTest, ReversedDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(-28.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 6.05, -78.686); +} + +TEST_F(RandomTest, StringIntegerRange) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45", "12"); +} + +TEST_F(RandomTest, StringIntegerRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45", "12"); +} + +TEST_F(RandomTest, StringDoubleToInteger) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45.0", "12"); +} + +TEST_F(RandomTest, StringDoubleToInteger_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45.0", "12"); +} + +TEST_F(RandomTest, StringIntegerToDouble) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45", "12.0"); +} + +TEST_F(RandomTest, StringIntegerToDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45", "12.0"); +} + +TEST_F(RandomTest, StringDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(2.587964)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45.0", "12.0"); +} + +TEST_F(RandomTest, StringDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(2.587964)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45.0", "12.0"); +} + +TEST_F(RandomTest, StringReversedDoubleRange) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "6.05", "-78.686"); +} + +TEST_F(RandomTest, StringReversedDoubleRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "6.05", "-78.686"); +} + +TEST_F(RandomTest, MixedStringIntegerWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45", 12); +} + +TEST_F(RandomTest, MixedStringIntegerWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45", 12); +} + +TEST_F(RandomTest, MixedNumberWithStringInteger) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -45, "12"); +} + +TEST_F(RandomTest, MixedNumberWithStringInteger_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -45, "12"); +} + +TEST_F(RandomTest, MixedStringDoubleWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-45.0", 12); +} + +TEST_F(RandomTest, MixedStringDoubleWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-45.0", 12); +} + +TEST_F(RandomTest, MixedNumberWithStringDouble) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -45, "12.0"); +} + +TEST_F(RandomTest, MixedNumberWithStringDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -45, "12.0"); +} + +TEST_F(RandomTest, MixedDoubleWithStringDouble) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 6.05, "-78.686"); +} + +TEST_F(RandomTest, MixedDoubleWithStringDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 6.05, "-78.686"); +} + +TEST_F(RandomTest, MixedStringDoubleWithDouble) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "6.05", -78.686); +} + +TEST_F(RandomTest, MixedStringDoubleWithDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "6.05", -78.686); +} + +TEST_F(RandomTest, BooleanRange) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 1)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, false, true); +} + +TEST_F(RandomTest, BooleanRange_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 1)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, false, true); +} + +TEST_F(RandomTest, BooleanWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint(1, 5)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, true, 5); +} + +TEST_F(RandomTest, BooleanWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(1, 5)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, true, 5); +} + +TEST_F(RandomTest, NumberWithBoolean) +{ + EXPECT_CALL(m_utils.rng(), randint(8, 0)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 8, false); +} + +TEST_F(RandomTest, NumberWithBoolean_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(8, 0)).WillRepeatedly(Return(1)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 8, false); +} + +TEST_F(RandomTest, NaNWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 5)).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "NaN", 5); +} + +TEST_F(RandomTest, NaNWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 5)).WillRepeatedly(Return(5)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "NaN", 5); +} + +TEST_F(RandomTest, NumberWithNaN) +{ + EXPECT_CALL(m_utils.rng(), randint(5, 0)).WillRepeatedly(Return(3)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 5, "NaN"); +} + +TEST_F(RandomTest, NumberWithNaN_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(5, 0)).WillRepeatedly(Return(3)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 5, "NaN"); +} + +TEST_F(RandomTest, NaNWithNaN) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 0)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "NaN", "NaN"); +} + +TEST_F(RandomTest, NaNWithNaN_Const) +{ + EXPECT_CALL(m_utils.rng(), randint(0, 0)).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "NaN", "NaN"); +} + +TEST_F(RandomTest, InfinityWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "Infinity", 2); +} + +TEST_F(RandomTest, InfinityWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "Infinity", 2); +} + +TEST_F(RandomTest, NumberWithInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -8, "Infinity"); +} + +TEST_F(RandomTest, NumberWithInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -8, "Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithNumber) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-Infinity", -2); +} + +TEST_F(RandomTest, NegativeInfinityWithNumber_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-Infinity", -2); +} + +TEST_F(RandomTest, NumberWithNegativeInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 8, "-Infinity"); +} + +TEST_F(RandomTest, NumberWithNegativeInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 8, "-Infinity"); +} + +TEST_F(RandomTest, InfinityWithDouble) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "Infinity", 2.5); +} + +TEST_F(RandomTest, InfinityWithDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "Infinity", 2.5); +} + +TEST_F(RandomTest, DoubleWithInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, -8.09, "Infinity"); +} + +TEST_F(RandomTest, DoubleWithInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, -8.09, "Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithDouble) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-Infinity", -2.5); +} + +TEST_F(RandomTest, NegativeInfinityWithDouble_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-Infinity", -2.5); +} + +TEST_F(RandomTest, DoubleWithNegativeInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, 8.09, "-Infinity"); +} + +TEST_F(RandomTest, DoubleWithNegativeInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, 8.09, "-Infinity"); +} + +TEST_F(RandomTest, InfinityWithInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "Infinity", "Infinity"); +} + +TEST_F(RandomTest, InfinityWithInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "Infinity", "Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithNegativeInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-Infinity", "-Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithNegativeInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-Infinity", "-Infinity"); +} + +TEST_F(RandomTest, InfinityWithNegativeInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "Infinity", "-Infinity"); +} + +TEST_F(RandomTest, InfinityWithNegativeInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "Infinity", "-Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithInfinity) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, false, "-Infinity", "Infinity"); +} + +TEST_F(RandomTest, NegativeInfinityWithInfinity_Const) +{ + EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); + EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Random, true, "-Infinity", "Infinity"); +} diff --git a/test/codegen/operators/math/round_test.cpp b/test/codegen/operators/math/round_test.cpp new file mode 100644 index 000000000..c98fbe6b0 --- /dev/null +++ b/test/codegen/operators/math/round_test.cpp @@ -0,0 +1,156 @@ +#include +#include + +#include "codegentestutils.h" + +class RoundTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(RoundTest, FourPointZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, 4.0).toDouble(), 4.0); +} + +TEST_F(RoundTest, FourPointZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, 4.0).toDouble(), 4.0); +} + +TEST_F(RoundTest, NegativeFourPointZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -4.0).toDouble(), -4.0); +} + +TEST_F(RoundTest, NegativeFourPointZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -4.0).toDouble(), -4.0); +} + +TEST_F(RoundTest, ThreePointTwo) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, 3.2).toDouble(), 3.0); +} + +TEST_F(RoundTest, ThreePointTwo_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, 3.2).toDouble(), 3.0); +} + +TEST_F(RoundTest, ThreePointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, 3.5).toDouble(), 4.0); +} + +TEST_F(RoundTest, ThreePointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, 3.5).toDouble(), 4.0); +} + +TEST_F(RoundTest, ThreePointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, 3.6).toDouble(), 4.0); +} + +TEST_F(RoundTest, ThreePointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, 3.6).toDouble(), 4.0); +} + +TEST_F(RoundTest, NegativeTwoPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -2.4).toDouble(), -2.0); +} + +TEST_F(RoundTest, NegativeTwoPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -2.4).toDouble(), -2.0); +} + +TEST_F(RoundTest, NegativeTwoPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -2.5).toDouble(), -2.0); +} + +TEST_F(RoundTest, NegativeTwoPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -2.5).toDouble(), -2.0); +} + +TEST_F(RoundTest, NegativeTwoPointSix) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -2.6).toDouble(), -3.0); +} + +TEST_F(RoundTest, NegativeTwoPointSix_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -2.6).toDouble(), -3.0); +} + +TEST_F(RoundTest, NegativeZeroPointFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -0.4).toDouble(), -0.0); +} + +TEST_F(RoundTest, NegativeZeroPointFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -0.4).toDouble(), -0.0); +} + +TEST_F(RoundTest, NegativeZeroPointFive) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -0.5).toDouble(), -0.0); +} + +TEST_F(RoundTest, NegativeZeroPointFive_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -0.5).toDouble(), -0.0); +} + +TEST_F(RoundTest, NegativeZeroPointFiftyOne) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -0.51).toDouble(), -1.0); +} + +TEST_F(RoundTest, NegativeZeroPointFiftyOne_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -0.51).toDouble(), -1.0); +} + +TEST_F(RoundTest, Infinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, inf).toDouble(), inf); +} + +TEST_F(RoundTest, Infinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, inf).toDouble(), inf); +} + +TEST_F(RoundTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, -inf).toDouble(), -inf); +} + +TEST_F(RoundTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, -inf).toDouble(), -inf); +} + +TEST_F(RoundTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, false, nan).toDouble(), 0); +} + +TEST_F(RoundTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Round, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/sin_test.cpp b/test/codegen/operators/math/sin_test.cpp new file mode 100644 index 000000000..c4d768444 --- /dev/null +++ b/test/codegen/operators/math/sin_test.cpp @@ -0,0 +1,136 @@ +#include +#include + +#include "codegentestutils.h" + +class SinTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(SinTest, ThirtyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 30.0).toDouble(), 0.5); +} + +TEST_F(SinTest, ThirtyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 30.0).toDouble(), 0.5); +} + +TEST_F(SinTest, NinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 90.0).toDouble(), 1.0); +} + +TEST_F(SinTest, NinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 90.0).toDouble(), 1.0); +} + +TEST_F(SinTest, VerySmallAngle) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 2.8e-9).toDouble(), 0.0); +} + +TEST_F(SinTest, VerySmallAngle_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 2.8e-9).toDouble(), 0.0); +} + +TEST_F(SinTest, SlightlyLargerSmallAngle) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 2.9e-9).toDouble(), 1e-10); +} + +TEST_F(SinTest, SlightlyLargerSmallAngle_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 2.9e-9).toDouble(), 1e-10); +} + +TEST_F(SinTest, FiveSeventyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 570.0).toDouble(), -0.5); +} + +TEST_F(SinTest, FiveSeventyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 570.0).toDouble(), -0.5); +} + +TEST_F(SinTest, NegativeThirtyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, -30.0).toDouble(), -0.5); +} + +TEST_F(SinTest, NegativeThirtyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, -30.0).toDouble(), -0.5); +} + +TEST_F(SinTest, NegativeNinetyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, -90.0).toDouble(), -1.0); +} + +TEST_F(SinTest, NegativeNinetyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, -90.0).toDouble(), -1.0); +} + +TEST_F(SinTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, 0.0).toDouble(), 0.0); +} + +TEST_F(SinTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, 0.0).toDouble(), 0.0); +} + +TEST_F(SinTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, -0.0).toDouble(), 0.0); +} + +TEST_F(SinTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, -0.0).toDouble(), 0.0); +} + +TEST_F(SinTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, inf).isNaN()); +} + +TEST_F(SinTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, inf).isNaN()); +} + +TEST_F(SinTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, -inf).isNaN()); +} + +TEST_F(SinTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, -inf).isNaN()); +} + +TEST_F(SinTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, false, nan).toDouble(), 0); +} + +TEST_F(SinTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sin, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/sqrt_test.cpp b/test/codegen/operators/math/sqrt_test.cpp new file mode 100644 index 000000000..5a43b91dc --- /dev/null +++ b/test/codegen/operators/math/sqrt_test.cpp @@ -0,0 +1,96 @@ +#include +#include + +#include "codegentestutils.h" + +class SqrtTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(SqrtTest, SixteenPointZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, 16.0).toDouble(), 4.0); +} + +TEST_F(SqrtTest, SixteenPointZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, 16.0).toDouble(), 4.0); +} + +TEST_F(SqrtTest, ZeroPointZeroFour) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, 0.04).toDouble(), 0.2); +} + +TEST_F(SqrtTest, ZeroPointZeroFour_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, 0.04).toDouble(), 0.2); +} + +TEST_F(SqrtTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, 0.0).toDouble(), 0.0); +} + +TEST_F(SqrtTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, 0.0).toDouble(), 0.0); +} + +TEST_F(SqrtTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, -0.0).toDouble(), 0.0); +} + +TEST_F(SqrtTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, -0.0).toDouble(), 0.0); +} + +TEST_F(SqrtTest, NegativeFour) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, -4.0).isNaN()); +} + +TEST_F(SqrtTest, NegativeFour_Const) +{ + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, -4.0).isNaN()); +} + +TEST_F(SqrtTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, inf).toDouble(), inf); +} + +TEST_F(SqrtTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, inf).toDouble(), inf); +} + +TEST_F(SqrtTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, -inf).isNaN()); +} + +TEST_F(SqrtTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, -inf).isNaN()); +} + +TEST_F(SqrtTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, false, nan).toDouble(), 0); +} + +TEST_F(SqrtTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Sqrt, true, nan).toDouble(), 0); +} diff --git a/test/codegen/operators/math/subtract_test.cpp b/test/codegen/operators/math/subtract_test.cpp new file mode 100644 index 000000000..a97383d75 --- /dev/null +++ b/test/codegen/operators/math/subtract_test.cpp @@ -0,0 +1,130 @@ +#include +#include + +#include "codegentestutils.h" + +class SubtractTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(SubtractTest, PositiveIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, 50, 25); +} + +TEST_F(SubtractTest, PositiveIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, 50, 25); +} + +TEST_F(SubtractTest, NegativeWithPositive) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, -500, 25); +} + +TEST_F(SubtractTest, NegativeWithPositive_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, -500, 25); +} + +TEST_F(SubtractTest, NegativeIntegers) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, -500, -25); +} + +TEST_F(SubtractTest, NegativeIntegers_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, -500, -25); +} + +TEST_F(SubtractTest, StringDecimals) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "2.54", "6.28"); +} + +TEST_F(SubtractTest, StringDecimals_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "2.54", "6.28"); +} + +TEST_F(SubtractTest, MixedDecimalAndString) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, 2.54, "-6.28"); +} + +TEST_F(SubtractTest, MixedDecimalAndString_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, 2.54, "-6.28"); +} + +TEST_F(SubtractTest, BooleanValues) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, true, true); +} + +TEST_F(SubtractTest, BooleanValues_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, true, true); +} + +TEST_F(SubtractTest, InfinityMinusInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "Infinity", "Infinity"); +} + +TEST_F(SubtractTest, InfinityMinusInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "Infinity", "Infinity"); +} + +TEST_F(SubtractTest, InfinityMinusNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "Infinity", "-Infinity"); +} + +TEST_F(SubtractTest, InfinityMinusNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "Infinity", "-Infinity"); +} + +TEST_F(SubtractTest, NegativeInfinityMinusInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "-Infinity", "Infinity"); +} + +TEST_F(SubtractTest, NegativeInfinityMinusInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "-Infinity", "Infinity"); +} + +TEST_F(SubtractTest, NegativeInfinityMinusNegativeInfinity) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "-Infinity", "-Infinity"); +} + +TEST_F(SubtractTest, NegativeInfinityMinusNegativeInfinity_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "-Infinity", "-Infinity"); +} + +TEST_F(SubtractTest, NumberMinusNaN) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, 1, "NaN"); +} + +TEST_F(SubtractTest, NumberMinusNaN_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, 1, "NaN"); +} + +TEST_F(SubtractTest, NaNMinusNumber) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, false, "NaN", 1); +} + +TEST_F(SubtractTest, NaNMinusNumber_Const) +{ + ASSERT_NUM_OP2(m_utils, CodeGenTestUtils::OpType::Sub, true, "NaN", 1); +} diff --git a/test/codegen/operators/math/tan_test.cpp b/test/codegen/operators/math/tan_test.cpp new file mode 100644 index 000000000..9f009410b --- /dev/null +++ b/test/codegen/operators/math/tan_test.cpp @@ -0,0 +1,188 @@ +#include +#include + +#include "codegentestutils.h" + +class TanTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(TanTest, FortyFiveDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 45.0).toDouble(), 1.0); +} + +TEST_F(TanTest, FortyFiveDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 45.0).toDouble(), 1.0); +} + +TEST_F(TanTest, NinetyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 90.0).toDouble(), inf); +} + +TEST_F(TanTest, NinetyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 90.0).toDouble(), inf); +} + +TEST_F(TanTest, TwoSeventyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 270.0).toDouble(), -inf); +} + +TEST_F(TanTest, TwoSeventyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 270.0).toDouble(), -inf); +} + +TEST_F(TanTest, FourFiftyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 450.0).toDouble(), inf); +} + +TEST_F(TanTest, FourFiftyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 450.0).toDouble(), inf); +} + +TEST_F(TanTest, NegativeNinetyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -90.0).toDouble(), -inf); +} + +TEST_F(TanTest, NegativeNinetyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -90.0).toDouble(), -inf); +} + +TEST_F(TanTest, NegativeTwoSeventyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -270.0).toDouble(), inf); +} + +TEST_F(TanTest, NegativeTwoSeventyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -270.0).toDouble(), inf); +} + +TEST_F(TanTest, NegativeFourFiftyDegrees) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -450.0).toDouble(), -inf); +} + +TEST_F(TanTest, NegativeFourFiftyDegrees_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -450.0).toDouble(), -inf); +} + +TEST_F(TanTest, OneEightyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 180.0).toDouble(), 0.0); +} + +TEST_F(TanTest, OneEightyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 180.0).toDouble(), 0.0); +} + +TEST_F(TanTest, NegativeOneEightyDegrees) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -180.0).toDouble(), 0.0); +} + +TEST_F(TanTest, NegativeOneEightyDegrees_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -180.0).toDouble(), 0.0); +} + +TEST_F(TanTest, VerySmallAngle) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 2.87e-9).toDouble(), 1e-10); +} + +TEST_F(TanTest, VerySmallAngle_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 2.87e-9).toDouble(), 1e-10); +} + +TEST_F(TanTest, EvenSmallerAngle) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 2.8647e-9).toDouble(), 0.0); +} + +TEST_F(TanTest, EvenSmallerAngle_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 2.8647e-9).toDouble(), 0.0); +} + +TEST_F(TanTest, PositiveZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, 0.0).toDouble(), 0.0); +} + +TEST_F(TanTest, PositiveZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, 0.0).toDouble(), 0.0); +} + +TEST_F(TanTest, NegativeZero) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -0.0).toDouble(), 0.0); +} + +TEST_F(TanTest, NegativeZero_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -0.0).toDouble(), 0.0); +} + +TEST_F(TanTest, PositiveInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, inf).isNaN()); +} + +TEST_F(TanTest, PositiveInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, inf).isNaN()); +} + +TEST_F(TanTest, NegativeInfinity) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, -inf).isNaN()); +} + +TEST_F(TanTest, NegativeInfinity_Const) +{ + static const double inf = std::numeric_limits::infinity(); + ASSERT_TRUE(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, -inf).isNaN()); +} + +TEST_F(TanTest, NaN) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, false, nan).toDouble(), 0.0); +} + +TEST_F(TanTest, NaN_Const) +{ + static const double nan = std::numeric_limits::quiet_NaN(); + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::Tan, true, nan).toDouble(), 0.0); +} diff --git a/test/codegen/operators/string/string_char_test.cpp b/test/codegen/operators/string/string_char_test.cpp new file mode 100644 index 000000000..d3b4e4996 --- /dev/null +++ b/test/codegen/operators/string/string_char_test.cpp @@ -0,0 +1,80 @@ +#include +#include + +#include "codegentestutils.h" + +class StringCharTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(StringCharTest, HelloWorldSecondChar) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "Hello world", 1).toString(), "e"); +} + +TEST_F(StringCharTest, HelloWorldSecondChar_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "Hello world", 1).toString(), "e"); +} + +TEST_F(StringCharTest, HelloWorldZeroIndex) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "Hello world", 0).toString(), "H"); +} + +TEST_F(StringCharTest, HelloWorldZeroIndex_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "Hello world", 0).toString(), "H"); +} + +TEST_F(StringCharTest, HelloWorldOutOfRange) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "Hello world", 11).toString(), ""); +} + +TEST_F(StringCharTest, HelloWorldOutOfRange_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "Hello world", 11).toString(), ""); +} + +TEST_F(StringCharTest, AbcThirdChar) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "abc", 2).toString(), "c"); +} + +TEST_F(StringCharTest, AbcThirdChar_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "abc", 2).toString(), "c"); +} + +TEST_F(StringCharTest, AbcNegativeIndex) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "abc", -1).toString(), ""); +} + +TEST_F(StringCharTest, AbcNegativeIndex_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "abc", -1).toString(), ""); +} + +TEST_F(StringCharTest, AbcOutOfRange) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "abc", 3).toString(), ""); +} + +TEST_F(StringCharTest, AbcOutOfRange_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "abc", 3).toString(), ""); +} + +TEST_F(StringCharTest, UnicodeString) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, false, "ábč", 0).toString(), "á"); +} + +TEST_F(StringCharTest, UnicodeString_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringChar, true, "ábč", 0).toString(), "á"); +} diff --git a/test/codegen/operators/string/string_concat_test.cpp b/test/codegen/operators/string/string_concat_test.cpp new file mode 100644 index 000000000..82410daab --- /dev/null +++ b/test/codegen/operators/string/string_concat_test.cpp @@ -0,0 +1,40 @@ +#include +#include + +#include "codegentestutils.h" + +class StringConcatTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(StringConcatTest, HelloWorld) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, false, "Hello ", "world").toString(), "Hello world"); +} + +TEST_F(StringConcatTest, HelloWorld_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, true, "Hello ", "world").toString(), "Hello world"); +} + +TEST_F(StringConcatTest, AbcDef) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, false, "abc", "def").toString(), "abcdef"); +} + +TEST_F(StringConcatTest, AbcDef_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, true, "abc", "def").toString(), "abcdef"); +} + +TEST_F(StringConcatTest, UnicodeStrings) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, false, "ábč", "ďéfgh").toString(), "ábčďéfgh"); +} + +TEST_F(StringConcatTest, UnicodeStrings_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringConcat, true, "ábč", "ďéfgh").toString(), "ábčďéfgh"); +} diff --git a/test/codegen/operators/string/string_equal_case_insensitive_test.cpp b/test/codegen/operators/string/string_equal_case_insensitive_test.cpp new file mode 100644 index 000000000..60a8a5398 --- /dev/null +++ b/test/codegen/operators/string/string_equal_case_insensitive_test.cpp @@ -0,0 +1,1210 @@ +#include +#include + +#include "codegentestutils.h" + +class StringEqualCaseInsensitiveTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(StringEqualCaseInsensitiveTest, SameIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 10, 10); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 10, 10); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 10, 8); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 10, 8); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentIntegersReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 8, 10); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentIntegersReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 8, 10); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, -4.25, -4.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, -4.25, -4.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, -4.25, 5.312); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, -4.25, 5.312); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentDecimalsReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.312, -4.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentDecimalsReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.312, -4.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, false); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, false); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentBooleansReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentBooleansReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 1, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 1, true); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 1, false); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 1, false); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "abC def", "abC def"); +} + +TEST_F(StringEqualCaseInsensitiveTest, SameStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "abC def", "abC def"); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringsCaseDifferent) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "abC def", "abc dEf"); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringsCaseDifferent_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "abC def", "abc dEf"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "abC def", "ghi Jkl"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "abC def", "ghi Jkl"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringsLonger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "abC def", "hello world"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringsLonger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "abC def", "hello world"); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, " ", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, " ", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, " ", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, " ", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, " ", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, SpaceVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, " ", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, EmptyVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, EmptyVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, EmptyVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, EmptyVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroStringVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "0", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroStringVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "0", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroNumberVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.25"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.25"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ExactStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "5.25", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, ExactStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "5.25", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithLeadingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.25, " 5.25"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithLeadingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.25, " 5.25"); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithLeadingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, " 5.25", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithLeadingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, " 5.25", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.25 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.25 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithTrailingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "5.25 ", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithTrailingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "5.25 ", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithSurroundingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.25, " 5.25 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithSurroundingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.25, " 5.25 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithSurroundingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, " 5.25 ", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithSurroundingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, " 5.25 ", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsDifferentString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.26"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsDifferentString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.26"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "5.26", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "5.26", 5.25); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringNumbers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "5.25", "5.26"); +} + +TEST_F(StringEqualCaseInsensitiveTest, DifferentStringNumbers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "5.25", "5.26"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5, "5 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5, "5 "); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithTrailingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "5 ", 5); +} + +TEST_F(StringEqualCaseInsensitiveTest, StringWithTrailingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "5 ", 5); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroVsOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "1"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroVsOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "1"); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "1", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "1", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroVsTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "test"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroVsTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "test"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TestStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "test", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, TestStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "test", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 5, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NumberWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 5, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "TRUE", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "TRUE", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "FALSE", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "FALSE", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "00001"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "00001"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "00001", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "00001", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "00000"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "00000"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "00000", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "00000", true); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "00000"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "00000"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "00000", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "00000", false); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", 1); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", 1); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 1, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 1, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "true"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", 0); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 0, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 0, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", 1); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", 1); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, 1, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, 1, "false"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "true", "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "true", "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", "FALSE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "false", "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "false", "TRUE"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, true, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, true, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, false, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, false, "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-infinity", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-infinity", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "nan", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "nan", "Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "nan", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "nan", "-Infinity"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "nan", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "nan", "NaN"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "Infinity", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, InfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "Infinity", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NegativeInfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "abc"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", " "); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", ""); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, false, "NaN", "0"); +} + +TEST_F(StringEqualCaseInsensitiveTest, NaNWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCI, true, "NaN", "0"); +} diff --git a/test/codegen/operators/string/string_equal_case_sensitive_test.cpp b/test/codegen/operators/string/string_equal_case_sensitive_test.cpp new file mode 100644 index 000000000..e9e196efc --- /dev/null +++ b/test/codegen/operators/string/string_equal_case_sensitive_test.cpp @@ -0,0 +1,1210 @@ +#include +#include + +#include "codegentestutils.h" + +class StringEqualCaseSensitiveTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(StringEqualCaseSensitiveTest, SameIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 10, 10); +} + +TEST_F(StringEqualCaseSensitiveTest, SameIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 10, 10); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentIntegers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 10, 8); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentIntegers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 10, 8); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentIntegersReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 8, 10); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentIntegersReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 8, 10); +} + +TEST_F(StringEqualCaseSensitiveTest, SameDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, -4.25, -4.25); +} + +TEST_F(StringEqualCaseSensitiveTest, SameDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, -4.25, -4.25); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentDecimals) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, -4.25, 5.312); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentDecimals_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, -4.25, 5.312); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentDecimalsReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.312, -4.25); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentDecimalsReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.312, -4.25); +} + +TEST_F(StringEqualCaseSensitiveTest, SameBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, true); +} + +TEST_F(StringEqualCaseSensitiveTest, SameBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, true); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentBooleans) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, false); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentBooleans_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, false); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentBooleansReversed) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, true); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentBooleansReversed_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, true); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 1, true); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 1, true); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 1, false); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 1, false); +} + +TEST_F(StringEqualCaseSensitiveTest, SameStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "abC def", "abC def"); +} + +TEST_F(StringEqualCaseSensitiveTest, SameStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "abC def", "abC def"); +} + +TEST_F(StringEqualCaseSensitiveTest, StringsCaseDifferent) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "abC def", "abc dEf"); +} + +TEST_F(StringEqualCaseSensitiveTest, StringsCaseDifferent_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "abC def", "abc dEf"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStrings) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "abC def", "ghi Jkl"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStrings_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "abC def", "ghi Jkl"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringsLonger) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "abC def", "hello world"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringsLonger_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "abC def", "hello world"); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, " ", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, " ", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, " ", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, " ", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, " ", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, SpaceVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, " ", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, " "); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, " "); +} + +TEST_F(StringEqualCaseSensitiveTest, EmptyVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, EmptyVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, EmptyVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, EmptyVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsEmpty) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, ""); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsEmpty_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, ""); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroStringVsZeroNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "0", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroStringVsZeroNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "0", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroNumberVsZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsExactString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.25"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsExactString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.25"); +} + +TEST_F(StringEqualCaseSensitiveTest, ExactStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "5.25", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, ExactStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "5.25", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithLeadingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.25, " 5.25"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithLeadingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.25, " 5.25"); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithLeadingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, " 5.25", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithLeadingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, " 5.25", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.25 "); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.25 "); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithTrailingSpaceVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "5.25 ", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithTrailingSpaceVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "5.25 ", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithSurroundingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.25, " 5.25 "); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithSurroundingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.25, " 5.25 "); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithSurroundingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, " 5.25 ", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithSurroundingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, " 5.25 ", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsDifferentString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.26"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsDifferentString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.26"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "5.26", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "5.26", 5.25); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringNumbers) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "5.25", "5.26"); +} + +TEST_F(StringEqualCaseSensitiveTest, DifferentStringNumbers_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "5.25", "5.26"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpaces) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5, "5 "); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpaces_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5, "5 "); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithTrailingSpacesVsNumber) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "5 ", 5); +} + +TEST_F(StringEqualCaseSensitiveTest, StringWithTrailingSpacesVsNumber_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "5 ", 5); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroVsOneString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "1"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroVsOneString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "1"); +} + +TEST_F(StringEqualCaseSensitiveTest, OneStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "1", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, OneStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "1", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroVsTestString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "test"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroVsTestString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "test"); +} + +TEST_F(StringEqualCaseSensitiveTest, TestStringVsZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "test", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, TestStringVsZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "test", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 5, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NumberWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 5, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", true); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", true); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", false); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", false); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", false); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", false); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", true); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", true); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, UppercaseTrueStringWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "TRUE", true); +} + +TEST_F(StringEqualCaseSensitiveTest, UppercaseTrueStringWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "TRUE", true); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, UppercaseFalseStringWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "FALSE", false); +} + +TEST_F(StringEqualCaseSensitiveTest, UppercaseFalseStringWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "FALSE", false); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "00001"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "00001"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedOneWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "00001", true); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedOneWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "00001", true); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "00000"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "00000"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedZeroWithTrueBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "00000", true); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedZeroWithTrueBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "00000", true); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithZeroPaddedZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "00000"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithZeroPaddedZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "00000"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedZeroWithFalseBoolean) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "00000", false); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroPaddedZeroWithFalseBoolean_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "00000", false); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", 1); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", 1); +} + +TEST_F(StringEqualCaseSensitiveTest, OneWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 1, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, OneWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 1, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "true"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithZero) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithZero_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", 0); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 0, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, ZeroWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 0, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithOne) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", 1); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithOne_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", 1); +} + +TEST_F(StringEqualCaseSensitiveTest, OneWithFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, 1, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, OneWithFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, 1, "false"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "true", "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "true", "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithUppercaseFalseString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithUppercaseFalseString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", "FALSE"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithUppercaseTrueString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "false", "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseStringWithUppercaseTrueString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "false", "TRUE"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, true, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, TrueBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, true, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, false, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, FalseBooleanWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, false, "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-infinity", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-infinity", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-infinity", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "nan", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "nan", "Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithNegativeInfinity) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "nan", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithNegativeInfinity_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "nan", "-Infinity"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithNaN) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "nan", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, LowercaseNaNStringWithNaN_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "nan", "NaN"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "Infinity", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, InfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "Infinity", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, NegativeInfinityWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithStringAbc) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithStringAbc_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "abc"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithStringSpace) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithStringSpace_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", " "); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithEmptyString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithEmptyString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", ""); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithZeroString) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, false, "NaN", "0"); +} + +TEST_F(StringEqualCaseSensitiveTest, NaNWithZeroString_Const) +{ + ASSERT_BOOL_OP2(m_utils, CodeGenTestUtils::OpType::StrCmpEQCS, true, "NaN", "0"); +} diff --git a/test/codegen/operators/string/string_length_test.cpp b/test/codegen/operators/string/string_length_test.cpp new file mode 100644 index 000000000..2c189fc10 --- /dev/null +++ b/test/codegen/operators/string/string_length_test.cpp @@ -0,0 +1,50 @@ +#include +#include + +#include "codegentestutils.h" + +class StringLengthTest : public testing::Test +{ + public: + CodeGenTestUtils m_utils; +}; + +TEST_F(StringLengthTest, HelloWorld) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, false, "Hello world").toDouble(), 11); +} + +TEST_F(StringLengthTest, HelloWorld_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, true, "Hello world").toDouble(), 11); +} + +TEST_F(StringLengthTest, Abc) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, false, "abc").toDouble(), 3); +} + +TEST_F(StringLengthTest, Abc_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, true, "abc").toDouble(), 3); +} + +TEST_F(StringLengthTest, Abcdef) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, false, "abcdef").toDouble(), 6); +} + +TEST_F(StringLengthTest, Abcdef_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, true, "abcdef").toDouble(), 6); +} + +TEST_F(StringLengthTest, UnicodeString) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, false, "ábč").toDouble(), 3); +} + +TEST_F(StringLengthTest, UnicodeString_Const) +{ + ASSERT_EQ(m_utils.getOpResult(CodeGenTestUtils::OpType::StringLength, true, "ábč").toDouble(), 3); +} diff --git a/test/llvm/CMakeLists.txt b/test/llvm/CMakeLists.txt index 62ea1edf7..96e8c6897 100644 --- a/test/llvm/CMakeLists.txt +++ b/test/llvm/CMakeLists.txt @@ -16,47 +16,12 @@ target_link_libraries( add_executable( llvm_test main.cpp - llvmtestutils.cpp - llvmtestutils.h llvmexecutioncontext_test.cpp llvmexecutablecode_test.cpp llvminstructionlist_test.cpp code_analyzer/variable_type_analysis.cpp code_analyzer/list_type_analysis.cpp code_analyzer/mixed_type_analysis.cpp - operators/equal_comparison_test.cpp - operators/greater_than_test.cpp - operators/less_than_test.cpp - operators/math/add_test.cpp - operators/math/subtract_test.cpp - operators/math/multiply_test.cpp - operators/math/divide_test.cpp - operators/math/random_test.cpp - operators/math/random_int_test.cpp - operators/math/mod_test.cpp - operators/math/abs_test.cpp - operators/math/round_test.cpp - operators/math/floor_test.cpp - operators/math/ceil_test.cpp - operators/math/sqrt_test.cpp - operators/math/sin_test.cpp - operators/math/cos_test.cpp - operators/math/tan_test.cpp - operators/math/asin_test.cpp - operators/math/acos_test.cpp - operators/math/atan_test.cpp - operators/math/ln_test.cpp - operators/math/log10_test.cpp - operators/math/exp_test.cpp - operators/math/exp10_test.cpp - operators/logic/and_test.cpp - operators/logic/or_test.cpp - operators/logic/not_test.cpp - operators/string/string_equal_case_sensitive_test.cpp - operators/string/string_equal_case_insensitive_test.cpp - operators/string/string_concat_test.cpp - operators/string/string_char_test.cpp - operators/string/string_length_test.cpp ) target_link_libraries( diff --git a/test/llvm/llvmtestutils.cpp b/test/llvm/llvmtestutils.cpp deleted file mode 100644 index b31ad1df7..000000000 --- a/test/llvm/llvmtestutils.cpp +++ /dev/null @@ -1,375 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "llvmtestutils.h" -#include "testfunctions.h" - -using namespace libscratchcpp; - -using ::testing::ReturnRef; - -LLVMTestUtils::LLVMTestUtils() -{ - test_function(nullptr, nullptr, nullptr, nullptr, nullptr); // force dependency - - EXPECT_CALL(m_engine, targets()).WillRepeatedly(ReturnRef(m_emptyTargets)); -} - -LLVMCodeBuilder *LLVMTestUtils::createBuilder(Target *target, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) -{ - if (m_contexts.find(target) == m_contexts.cend() || !target) - m_contexts[target] = std::make_shared(&m_engine, target); - - m_contextList.push_back(m_contexts[target]); - m_builder = std::make_shared(m_contexts[target].get(), procedurePrototype, codeType); - - return m_builder.get(); -} - -LLVMCodeBuilder *LLVMTestUtils::createBuilder(Target *target, bool warp) -{ - m_procedurePrototype = std::make_shared("test"); - m_procedurePrototype->setWarp(warp); - createBuilder(target, m_procedurePrototype.get()); - - return m_builder.get(); -} - -LLVMCodeBuilder *LLVMTestUtils::createBuilder(bool warp) -{ - return createBuilder(nullptr, warp); -} - -LLVMCodeBuilder *LLVMTestUtils::createReporterBuilder(Target *target) -{ - return createBuilder(target, nullptr, Compiler::CodeType::Reporter); -} - -LLVMCodeBuilder *LLVMTestUtils::createPredicateBuilder(Target *target) -{ - return createBuilder(target, nullptr, Compiler::CodeType::HatPredicate); -} - -CompilerValue *LLVMTestUtils::callConstFuncForType(ValueType type, CompilerValue *arg) -{ - switch (type) { - case ValueType::Number: - return m_builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number }, { arg }); - - case ValueType::Bool: - return m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { arg }); - - case ValueType::String: - return m_builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { arg }); - - default: - EXPECT_TRUE(false); - return nullptr; - } -} - -CompilerValue *LLVMTestUtils::callConstFuncForType(ValueType type, CompilerValue *arg, Compiler::StaticType returnType) -{ - switch (type) { - case ValueType::Number: - return m_builder->addFunctionCall("test_const_number_unknown", returnType, { Compiler::StaticType::Number }, { arg }); - - case ValueType::Bool: - return m_builder->addFunctionCall("test_const_bool_unknown", returnType, { Compiler::StaticType::Bool }, { arg }); - - case ValueType::String: - return m_builder->addFunctionCall("test_const_string_unknown", returnType, { Compiler::StaticType::String }, { arg }); - - default: - EXPECT_TRUE(false); - } - - return nullptr; -} - -Value LLVMTestUtils::getOpResult(OpType type, bool rawArg, const Value &v) -{ - createReporterBuilder(nullptr); - - CompilerValue *arg = m_builder->addConstValue(v); - - if (rawArg) - addOp(type, arg); - else { - arg = callConstFuncForType(v.type(), arg); - addOp(type, arg); - } - - auto code = m_builder->build(); - Script script(&m_target, nullptr, nullptr); - script.setCode(code); - Thread thread(&m_target, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - - ValueData data = code->runReporter(ctx.get()); - Value ret(data); - value_free(&data); - - return ret; -} - -Value LLVMTestUtils::getOpResult(OpType type, bool rawArgs, const Value &v1, const Value &v2) -{ - createReporterBuilder(nullptr); - - CompilerValue *arg1 = m_builder->addConstValue(v1); - CompilerValue *arg2 = m_builder->addConstValue(v2); - - if (rawArgs) - addOp(type, arg1, arg2); - else { - arg1 = callConstFuncForType(v1.type(), arg1); - arg2 = callConstFuncForType(v2.type(), arg2); - addOp(type, arg1, arg2); - } - - auto code = m_builder->build(); - Script script(&m_target, nullptr, nullptr); - script.setCode(code); - Thread thread(&m_target, nullptr, &script); - auto ctx = code->createExecutionContext(&thread); - ctx->setRng(&m_rng); - - ValueData data = code->runReporter(ctx.get()); - Value ret(data); - value_free(&data); - - return ret; -} - -Value LLVMTestUtils::getExpectedOpResult(OpType type, const Value &v) -{ - switch (type) { - case OpType::Not: - return !v.toBool(); - - case OpType::StringLength: - return v.toUtf16().size(); - - default: - EXPECT_TRUE(false); - return Value(); - } -} - -Value LLVMTestUtils::getExpectedOpResult(OpType type, const Value &v1, const Value &v2) -{ - switch (type) { - case OpType::Add: - return v1 + v2; - - case OpType::Sub: - return v1 - v2; - - case OpType::Mul: - return v1 * v2; - - case OpType::Div: - return v1 / v2; - - case OpType::Random: { - const double sum = v1.toDouble() + v2.toDouble(); - - if (std::isnan(sum) || std::isinf(sum)) - return sum; - - return v1.isInt() && v2.isInt() ? m_rng.randint(v1.toLong(), v2.toLong()) : m_rng.randintDouble(v1.toDouble(), v2.toDouble()); - } - - case OpType::RandomInt: - return m_rng.randint(v1.toLong(), v2.toLong()); - - case OpType::CmpEQ: - return v1 == v2; - - case OpType::CmpGT: - return v1 > v2; - - case OpType::CmpLT: - return v1 < v2; - - case OpType::StrCmpEQCS: { - StringPtr *s1 = string_pool_new(); - StringPtr *s2 = string_pool_new(); - value_toStringPtr(&v1.data(), s1); - value_toStringPtr(&v2.data(), s2); - - bool ret = string_compare_case_sensitive(s1, s2) == 0; - - string_pool_free(s1); - string_pool_free(s2); - return ret; - } - - case OpType::StrCmpEQCI: { - StringPtr *s1 = string_pool_new(); - StringPtr *s2 = string_pool_new(); - value_toStringPtr(&v1.data(), s1); - value_toStringPtr(&v2.data(), s2); - - bool ret = string_compare_case_insensitive(s1, s2) == 0; - - string_pool_free(s1); - string_pool_free(s2); - return ret; - } - - case OpType::And: - return v1.toBool() && v2.toBool(); - - case OpType::Or: - return v1.toBool() || v2.toBool(); - - case OpType::Mod: - return v1 % v2; - - default: - EXPECT_TRUE(false); - return Value(); - } -} - -EngineMock &LLVMTestUtils::engine() -{ - return m_engine; -} - -TargetMock &LLVMTestUtils::target() -{ - return m_target; -} - -const RandomGeneratorMock &LLVMTestUtils::rng() const -{ - return m_rng; -} - -CompilerValue *LLVMTestUtils::addOp(OpType type, CompilerValue *arg) -{ - switch (type) { - case OpType::Not: - return m_builder->createNot(arg); - - case OpType::Round: - return m_builder->createRound(arg); - - case OpType::Abs: - return m_builder->createAbs(arg); - - case OpType::Floor: - return m_builder->createFloor(arg); - - case OpType::Ceil: - return m_builder->createCeil(arg); - - case OpType::Sqrt: - return m_builder->createSqrt(arg); - - case OpType::Sin: - return m_builder->createSin(arg); - - case OpType::Cos: - return m_builder->createCos(arg); - - case OpType::Tan: - return m_builder->createTan(arg); - - case OpType::Asin: - return m_builder->createAsin(arg); - - case OpType::Acos: - return m_builder->createAcos(arg); - - case OpType::Atan: - return m_builder->createAtan(arg); - - case OpType::Ln: - return m_builder->createLn(arg); - - case OpType::Log10: - return m_builder->createLog10(arg); - - case OpType::Exp: - return m_builder->createExp(arg); - - case OpType::Exp10: - return m_builder->createExp10(arg); - - case OpType::StringLength: - return m_builder->addStringLength(arg); - - default: - EXPECT_TRUE(false); - return nullptr; - } -} - -CompilerValue *LLVMTestUtils::addOp(OpType type, CompilerValue *arg1, CompilerValue *arg2) -{ - switch (type) { - case OpType::Add: - return m_builder->createAdd(arg1, arg2); - - case OpType::Sub: - return m_builder->createSub(arg1, arg2); - - case OpType::Mul: - return m_builder->createMul(arg1, arg2); - - case OpType::Div: - return m_builder->createDiv(arg1, arg2); - - case OpType::Random: - return m_builder->createRandom(arg1, arg2); - - case OpType::RandomInt: - return m_builder->createRandomInt(arg1, arg2); - - case OpType::CmpEQ: - return m_builder->createCmpEQ(arg1, arg2); - - case OpType::CmpGT: - return m_builder->createCmpGT(arg1, arg2); - - case OpType::CmpLT: - return m_builder->createCmpLT(arg1, arg2); - - case OpType::StrCmpEQCS: - return m_builder->createStrCmpEQ(arg1, arg2, true); - - case OpType::StrCmpEQCI: - return m_builder->createStrCmpEQ(arg1, arg2, false); - - case OpType::And: - return m_builder->createAnd(arg1, arg2); - - case OpType::Or: - return m_builder->createOr(arg1, arg2); - - case OpType::Mod: - return m_builder->createMod(arg1, arg2); - - case OpType::StringConcat: - return m_builder->createStringConcat(arg1, arg2); - - case OpType::StringChar: - return m_builder->addStringChar(arg1, arg2); - - default: - EXPECT_TRUE(false); - return nullptr; - } -} diff --git a/test/llvm/llvmtestutils.h b/test/llvm/llvmtestutils.h deleted file mode 100644 index 64380bc78..000000000 --- a/test/llvm/llvmtestutils.h +++ /dev/null @@ -1,108 +0,0 @@ -#pragma once - -#include -#include -#include -#include - -#define ASSERT_NUM_OP1(utils, type, rawArg, v) \ - Value result = utils.getOpResult(type, rawArg, v); \ - Value expected = utils.getExpectedOpResult(type, v); \ - ASSERT_EQ(result.isNaN(), expected.isNaN()); \ - ASSERT_EQ(result.toDouble(), expected.toDouble()); - -#define ASSERT_NUM_OP2(utils, type, rawArgs, v1, v2) \ - Value result = utils.getOpResult(type, rawArgs, v1, v2); \ - Value expected = utils.getExpectedOpResult(type, v1, v2); \ - ASSERT_EQ(result.isNaN(), expected.isNaN()); \ - ASSERT_EQ(result.toDouble(), expected.toDouble()); - -#define ASSERT_BOOL_OP1(utils, type, rawArg, v) ASSERT_EQ(utils.getOpResult(type, rawArg, v).toBool(), m_utils.getExpectedOpResult(type, v).toBool()); -#define ASSERT_BOOL_OP2(utils, type, rawArgs, v1, v2) ASSERT_EQ(utils.getOpResult(type, rawArgs, v1, v2).toBool(), m_utils.getExpectedOpResult(type, v1, v2).toBool()); - -#define ASSERT_STRING_OP1(utils, type, rawArg, v) ASSERT_EQ(utils.getOpResult(type, rawArg, v).toString(), m_utils.getExpectedOpResult(type, v).toString()); -#define ASSERT_STRING_OP2(utils, type, rawArgs, v1, v2) ASSERT_EQ(utils.getOpResult(type, rawArgs, v1, v2).toString(), m_utils.getExpectedOpResult(type, v1, v2).toString()); - -namespace libscratchcpp -{ - -class LLVMCompilerContext; -class LLVMCodeBuilder; - -class LLVMTestUtils -{ - public: - enum class OpType - { - Add, - Sub, - Mul, - Div, - Random, - RandomInt, - CmpEQ, - CmpGT, - CmpLT, - StrCmpEQCS, - StrCmpEQCI, - And, - Or, - Not, - Mod, - Round, - Abs, - Floor, - Ceil, - Sqrt, - Sin, - Cos, - Tan, - Asin, - Acos, - Atan, - Ln, - Log10, - Exp, - Exp10, - StringConcat, - StringChar, - StringLength - }; - - LLVMTestUtils(); - - LLVMCodeBuilder *createBuilder(Target *target, BlockPrototype *procedurePrototype, Compiler::CodeType codeType = Compiler::CodeType::Script); - LLVMCodeBuilder *createBuilder(Target *target, bool warp); - LLVMCodeBuilder *createBuilder(bool warp); - - LLVMCodeBuilder *createReporterBuilder(Target *target); - LLVMCodeBuilder *createPredicateBuilder(Target *target); - - CompilerValue *callConstFuncForType(ValueType type, CompilerValue *arg); - CompilerValue *callConstFuncForType(ValueType type, CompilerValue *arg, Compiler::StaticType returnType); - - Value getOpResult(OpType type, bool rawArg, const Value &v); - Value getOpResult(OpType type, bool rawArgs, const Value &v1, const Value &v2); - - Value getExpectedOpResult(OpType type, const Value &v); - Value getExpectedOpResult(OpType type, const Value &v1, const Value &v2); - - EngineMock &engine(); - TargetMock &target(); - const RandomGeneratorMock &rng() const; - - private: - CompilerValue *addOp(OpType type, CompilerValue *arg); - CompilerValue *addOp(OpType type, CompilerValue *arg1, CompilerValue *arg2); - - std::unordered_map> m_contexts; - std::vector> m_contextList; - std::shared_ptr m_builder; - std::shared_ptr m_procedurePrototype; - EngineMock m_engine; - TargetMock m_target; // NOTE: isStage() is used for call expectations - RandomGeneratorMock m_rng; - const std::vector> m_emptyTargets; -}; - -} // namespace libscratchcpp diff --git a/test/llvm/operators/equal_comparison_test.cpp b/test/llvm/operators/equal_comparison_test.cpp deleted file mode 100644 index 0e2c09a99..000000000 --- a/test/llvm/operators/equal_comparison_test.cpp +++ /dev/null @@ -1,1205 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMEqualComparisonTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMEqualComparisonTest, SameIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 10, 10); -} - -TEST_F(LLVMEqualComparisonTest, SameIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 10, 10); -} - -TEST_F(LLVMEqualComparisonTest, DifferentIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 10, 8); -} - -TEST_F(LLVMEqualComparisonTest, DifferentIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 10, 8); -} - -TEST_F(LLVMEqualComparisonTest, DifferentIntegersReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 8, 10); -} - -TEST_F(LLVMEqualComparisonTest, DifferentIntegersReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 8, 10); -} - -TEST_F(LLVMEqualComparisonTest, SameDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, -4.25, -4.25); -} - -TEST_F(LLVMEqualComparisonTest, SameDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, -4.25, -4.25); -} - -TEST_F(LLVMEqualComparisonTest, DifferentDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, -4.25, 5.312); -} - -TEST_F(LLVMEqualComparisonTest, DifferentDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, -4.25, 5.312); -} - -TEST_F(LLVMEqualComparisonTest, DifferentDecimalsReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.312, -4.25); -} - -TEST_F(LLVMEqualComparisonTest, DifferentDecimalsReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.312, -4.25); -} - -TEST_F(LLVMEqualComparisonTest, SameBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, true); -} - -TEST_F(LLVMEqualComparisonTest, SameBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, true); -} - -TEST_F(LLVMEqualComparisonTest, DifferentBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, false); -} - -TEST_F(LLVMEqualComparisonTest, DifferentBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, false); -} - -TEST_F(LLVMEqualComparisonTest, DifferentBooleansReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, true); -} - -TEST_F(LLVMEqualComparisonTest, DifferentBooleansReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, true); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 1, true); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 1, true); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 1, false); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 1, false); -} - -TEST_F(LLVMEqualComparisonTest, SameStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "abC def", "abC def"); -} - -TEST_F(LLVMEqualComparisonTest, SameStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "abC def", "abC def"); -} - -TEST_F(LLVMEqualComparisonTest, StringsCaseDifferent) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "abC def", "abc dEf"); -} - -TEST_F(LLVMEqualComparisonTest, StringsCaseDifferent_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "abC def", "abc dEf"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringsLonger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "abC def", "hello world"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringsLonger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "abC def", "hello world"); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, " ", ""); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, " ", ""); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, " ", "0"); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, " ", "0"); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, " ", 0); -} - -TEST_F(LLVMEqualComparisonTest, SpaceVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, " ", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, " "); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, " "); -} - -TEST_F(LLVMEqualComparisonTest, EmptyVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "", "0"); -} - -TEST_F(LLVMEqualComparisonTest, EmptyVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "", "0"); -} - -TEST_F(LLVMEqualComparisonTest, EmptyVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "", 0); -} - -TEST_F(LLVMEqualComparisonTest, EmptyVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, ""); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, ""); -} - -TEST_F(LLVMEqualComparisonTest, ZeroStringVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "0", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroStringVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "0", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "0"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroNumberVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "0"); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.25, "5.25"); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.25, "5.25"); -} - -TEST_F(LLVMEqualComparisonTest, ExactStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "5.25", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, ExactStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "5.25", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithLeadingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.25, " 5.25"); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithLeadingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.25, " 5.25"); -} - -TEST_F(LLVMEqualComparisonTest, StringWithLeadingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, " 5.25", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, StringWithLeadingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, " 5.25", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithTrailingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.25, "5.25 "); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithTrailingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.25, "5.25 "); -} - -TEST_F(LLVMEqualComparisonTest, StringWithTrailingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "5.25 ", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, StringWithTrailingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "5.25 ", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithSurroundingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.25, " 5.25 "); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithSurroundingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.25, " 5.25 "); -} - -TEST_F(LLVMEqualComparisonTest, StringWithSurroundingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, " 5.25 ", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, StringWithSurroundingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, " 5.25 ", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsDifferentString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5.25, "5.26"); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsDifferentString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5.25, "5.26"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "5.26", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "5.26", 5.25); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringNumbers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "5.25", "5.26"); -} - -TEST_F(LLVMEqualComparisonTest, DifferentStringNumbers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "5.25", "5.26"); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithTrailingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5, "5 "); -} - -TEST_F(LLVMEqualComparisonTest, NumberVsStringWithTrailingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5, "5 "); -} - -TEST_F(LLVMEqualComparisonTest, StringWithTrailingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "5 ", 5); -} - -TEST_F(LLVMEqualComparisonTest, StringWithTrailingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "5 ", 5); -} - -TEST_F(LLVMEqualComparisonTest, ZeroVsOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "1"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroVsOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "1"); -} - -TEST_F(LLVMEqualComparisonTest, OneStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "1", 0); -} - -TEST_F(LLVMEqualComparisonTest, OneStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "1", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroVsTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "test"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroVsTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "test"); -} - -TEST_F(LLVMEqualComparisonTest, TestStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "test", 0); -} - -TEST_F(LLVMEqualComparisonTest, TestStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "test", 0); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 5, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NumberWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 5, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "true"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "true"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", true); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "false"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "false"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", false); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", false); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "true"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "true"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", false); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "true", false); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "false"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "false"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", true); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", true); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "TRUE", true); -} - -TEST_F(LLVMEqualComparisonTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "TRUE", true); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "FALSE", false); -} - -TEST_F(LLVMEqualComparisonTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "FALSE", false); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "00001"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "00001"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "00001", true); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "00001", true); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "00000"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "00000"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "00000", true); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "00000", true); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "00000"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "00000"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "00000", false); -} - -TEST_F(LLVMEqualComparisonTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "00000", false); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", 1); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "true", 1); -} - -TEST_F(LLVMEqualComparisonTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 1, "true"); -} - -TEST_F(LLVMEqualComparisonTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 1, "true"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", 0); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "true", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "true"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "true"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", 0); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", 0); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 0, "false"); -} - -TEST_F(LLVMEqualComparisonTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 0, "false"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", 1); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", 1); -} - -TEST_F(LLVMEqualComparisonTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, 1, "false"); -} - -TEST_F(LLVMEqualComparisonTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, 1, "false"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "true", "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "true", "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "true", "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", "FALSE"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "false", "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "false", "TRUE"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, true, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, true, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, false, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, false, "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-infinity", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "nan", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "nan", "Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "nan", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "nan", "-Infinity"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "nan", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "nan", "NaN"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", " "); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", " "); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", ""); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", ""); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "Infinity", "0"); -} - -TEST_F(LLVMEqualComparisonTest, InfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "Infinity", "0"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", " "); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", " "); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", ""); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", ""); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "-Infinity", "0"); -} - -TEST_F(LLVMEqualComparisonTest, NegativeInfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "-Infinity", "0"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "abc"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", " "); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", " "); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", ""); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", ""); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, false, "NaN", "0"); -} - -TEST_F(LLVMEqualComparisonTest, NaNWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpEQ, true, "NaN", "0"); -} diff --git a/test/llvm/operators/greater_than_test.cpp b/test/llvm/operators/greater_than_test.cpp deleted file mode 100644 index 9256def56..000000000 --- a/test/llvm/operators/greater_than_test.cpp +++ /dev/null @@ -1,1340 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMGreaterThanTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMGreaterThanTest, SameIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 10, 10); -} - -TEST_F(LLVMGreaterThanTest, SameIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 10, 10); -} - -TEST_F(LLVMGreaterThanTest, FirstGreaterInteger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 10, 8); -} - -TEST_F(LLVMGreaterThanTest, FirstGreaterInteger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 10, 8); -} - -TEST_F(LLVMGreaterThanTest, SecondGreaterInteger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 8, 10); -} - -TEST_F(LLVMGreaterThanTest, SecondGreaterInteger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 8, 10); -} - -TEST_F(LLVMGreaterThanTest, SameDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, -4.25, -4.25); -} - -TEST_F(LLVMGreaterThanTest, SameDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, -4.25, -4.25); -} - -TEST_F(LLVMGreaterThanTest, FirstGreaterDecimal) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, -4.25, 5.312); -} - -TEST_F(LLVMGreaterThanTest, FirstGreaterDecimal_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, -4.25, 5.312); -} - -TEST_F(LLVMGreaterThanTest, SecondGreaterDecimal) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.312, -4.25); -} - -TEST_F(LLVMGreaterThanTest, SecondGreaterDecimal_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.312, -4.25); -} - -TEST_F(LLVMGreaterThanTest, SameBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, true); -} - -TEST_F(LLVMGreaterThanTest, SameBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, true); -} - -TEST_F(LLVMGreaterThanTest, TrueGreaterThanFalse) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, false); -} - -TEST_F(LLVMGreaterThanTest, TrueGreaterThanFalse_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, false); -} - -TEST_F(LLVMGreaterThanTest, FalseGreaterThanTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, true); -} - -TEST_F(LLVMGreaterThanTest, FalseGreaterThanTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, true); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 1, true); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 1, true); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 1, false); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 1, false); -} - -TEST_F(LLVMGreaterThanTest, SameStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "abC def", "abC def"); -} - -TEST_F(LLVMGreaterThanTest, SameStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "abC def", "abC def"); -} - -TEST_F(LLVMGreaterThanTest, StringsCaseDifferent) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "abC def", "abc dEf"); -} - -TEST_F(LLVMGreaterThanTest, StringsCaseDifferent_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "abC def", "abc dEf"); -} - -TEST_F(LLVMGreaterThanTest, FirstStringGreater) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMGreaterThanTest, FirstStringGreater_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMGreaterThanTest, SecondStringGreater) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "ghi Jkl", "abC def"); -} - -TEST_F(LLVMGreaterThanTest, SecondStringGreater_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "ghi Jkl", "abC def"); -} - -TEST_F(LLVMGreaterThanTest, StringsLengthComparison) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "abC def", "hello world"); -} - -TEST_F(LLVMGreaterThanTest, StringsLengthComparison_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "abC def", "hello world"); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, " ", ""); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, " ", ""); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, " ", "0"); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, " ", "0"); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, " ", 0); -} - -TEST_F(LLVMGreaterThanTest, SpaceGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, " ", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, " "); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, " "); -} - -TEST_F(LLVMGreaterThanTest, EmptyGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "", "0"); -} - -TEST_F(LLVMGreaterThanTest, EmptyGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "", "0"); -} - -TEST_F(LLVMGreaterThanTest, EmptyGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "", 0); -} - -TEST_F(LLVMGreaterThanTest, EmptyGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, ""); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, ""); -} - -TEST_F(LLVMGreaterThanTest, ZeroStringGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "0", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroStringGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "0", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "0"); -} - -TEST_F(LLVMGreaterThanTest, ZeroNumberGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "0"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.25, "5.25"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.25, "5.25"); -} - -TEST_F(LLVMGreaterThanTest, ExactStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "5.25", 5.25); -} - -TEST_F(LLVMGreaterThanTest, ExactStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "5.25", 5.25); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithLeadingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.25, " 5.25"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithLeadingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.25, " 5.25"); -} - -TEST_F(LLVMGreaterThanTest, StringWithLeadingSpaceGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, " 5.25", 5.25); -} - -TEST_F(LLVMGreaterThanTest, StringWithLeadingSpaceGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, " 5.25", 5.25); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithTrailingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.25, "5.25 "); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithTrailingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.25, "5.25 "); -} - -TEST_F(LLVMGreaterThanTest, StringWithTrailingSpaceGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "5.25 ", 5.25); -} - -TEST_F(LLVMGreaterThanTest, StringWithTrailingSpaceGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "5.25 ", 5.25); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithSurroundingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.25, " 5.25 "); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithSurroundingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.25, " 5.25 "); -} - -TEST_F(LLVMGreaterThanTest, StringWithSurroundingSpacesGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, " 5.25 ", 5.25); -} - -TEST_F(LLVMGreaterThanTest, StringWithSurroundingSpacesGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, " 5.25 ", 5.25); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanDifferentString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5.25, "5.26"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanDifferentString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5.25, "5.26"); -} - -TEST_F(LLVMGreaterThanTest, DifferentStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "5.26", 5.25); -} - -TEST_F(LLVMGreaterThanTest, DifferentStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "5.26", 5.25); -} - -TEST_F(LLVMGreaterThanTest, DifferentStringNumbers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "5.25", "5.26"); -} - -TEST_F(LLVMGreaterThanTest, DifferentStringNumbers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "5.25", "5.26"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithTrailingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5, "5 "); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanStringWithTrailingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5, "5 "); -} - -TEST_F(LLVMGreaterThanTest, StringWithTrailingSpacesGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "5 ", 5); -} - -TEST_F(LLVMGreaterThanTest, StringWithTrailingSpacesGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "5 ", 5); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "1"); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "1"); -} - -TEST_F(LLVMGreaterThanTest, OneStringGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "1", 0); -} - -TEST_F(LLVMGreaterThanTest, OneStringGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "1", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "test"); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "test"); -} - -TEST_F(LLVMGreaterThanTest, TestStringGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "test", 0); -} - -TEST_F(LLVMGreaterThanTest, TestStringGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "test", 0); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanAbcString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 55, "abc"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanAbcString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 55, "abc"); -} - -TEST_F(LLVMGreaterThanTest, AbcStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "abc", 55); -} - -TEST_F(LLVMGreaterThanTest, AbcStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "abc", 55); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", 5); -} - -TEST_F(LLVMGreaterThanTest, InfinityGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", 5); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", 5); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", 5); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 5, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NumberGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 5, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", 5); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", 5); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, ZeroGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", 0); -} - -TEST_F(LLVMGreaterThanTest, NaNGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", 0); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "true"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "true"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", true); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", true); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "false"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "false"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", false); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", false); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "true"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "true"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", false); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", false); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "false"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "false"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", true); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", true); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "TRUE", true); -} - -TEST_F(LLVMGreaterThanTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "TRUE", true); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "FALSE", false); -} - -TEST_F(LLVMGreaterThanTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "FALSE", false); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "00001"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "00001"); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "00001", true); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "00001", true); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "00000"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "00000"); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "00000", true); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "00000", true); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "00000"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "00000"); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "00000", false); -} - -TEST_F(LLVMGreaterThanTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "00000", false); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", 1); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", 1); -} - -TEST_F(LLVMGreaterThanTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 1, "true"); -} - -TEST_F(LLVMGreaterThanTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 1, "true"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", 0); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "true"); -} - -TEST_F(LLVMGreaterThanTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "true"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", 0); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", 0); -} - -TEST_F(LLVMGreaterThanTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 0, "false"); -} - -TEST_F(LLVMGreaterThanTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 0, "false"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", 1); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", 1); -} - -TEST_F(LLVMGreaterThanTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, 1, "false"); -} - -TEST_F(LLVMGreaterThanTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, 1, "false"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "true", "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "true", "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", "FALSE"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "false", "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "false", "TRUE"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", true); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", true); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", true); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", true); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, true, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, true, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", true); -} - -TEST_F(LLVMGreaterThanTest, NaNWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", true); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", false); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", false); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", false); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", false); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, false, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, false, "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", false); -} - -TEST_F(LLVMGreaterThanTest, NaNWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", false); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-infinity", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "nan", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "nan", "Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "nan", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "nan", "-Infinity"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "nan", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "nan", "NaN"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "abc"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "abc"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", " "); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", " "); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", ""); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", ""); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "Infinity", "0"); -} - -TEST_F(LLVMGreaterThanTest, InfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "Infinity", "0"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "abc"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "abc"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", " "); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", " "); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", ""); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", ""); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "-Infinity", "0"); -} - -TEST_F(LLVMGreaterThanTest, NegativeInfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "-Infinity", "0"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "abc"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "abc"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", " "); -} - -TEST_F(LLVMGreaterThanTest, NaNWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", " "); -} - -TEST_F(LLVMGreaterThanTest, NaNWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", ""); -} - -TEST_F(LLVMGreaterThanTest, NaNWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", ""); -} - -TEST_F(LLVMGreaterThanTest, NaNWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, false, "NaN", "0"); -} - -TEST_F(LLVMGreaterThanTest, NaNWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpGT, true, "NaN", "0"); -} diff --git a/test/llvm/operators/less_than_test.cpp b/test/llvm/operators/less_than_test.cpp deleted file mode 100644 index fcfcadc29..000000000 --- a/test/llvm/operators/less_than_test.cpp +++ /dev/null @@ -1,1340 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMLessThanTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMLessThanTest, SameIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 10, 10); -} - -TEST_F(LLVMLessThanTest, SameIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 10, 10); -} - -TEST_F(LLVMLessThanTest, FirstGreaterInteger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 10, 8); -} - -TEST_F(LLVMLessThanTest, FirstGreaterInteger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 10, 8); -} - -TEST_F(LLVMLessThanTest, SecondGreaterInteger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 8, 10); -} - -TEST_F(LLVMLessThanTest, SecondGreaterInteger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 8, 10); -} - -TEST_F(LLVMLessThanTest, SameDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, -4.25, -4.25); -} - -TEST_F(LLVMLessThanTest, SameDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, -4.25, -4.25); -} - -TEST_F(LLVMLessThanTest, FirstGreaterDecimal) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, -4.25, 5.312); -} - -TEST_F(LLVMLessThanTest, FirstGreaterDecimal_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, -4.25, 5.312); -} - -TEST_F(LLVMLessThanTest, SecondGreaterDecimal) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.312, -4.25); -} - -TEST_F(LLVMLessThanTest, SecondGreaterDecimal_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.312, -4.25); -} - -TEST_F(LLVMLessThanTest, SameBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, true); -} - -TEST_F(LLVMLessThanTest, SameBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, true); -} - -TEST_F(LLVMLessThanTest, TrueGreaterThanFalse) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, false); -} - -TEST_F(LLVMLessThanTest, TrueGreaterThanFalse_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, false); -} - -TEST_F(LLVMLessThanTest, FalseGreaterThanTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, true); -} - -TEST_F(LLVMLessThanTest, FalseGreaterThanTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, true); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 1, true); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 1, true); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 1, false); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 1, false); -} - -TEST_F(LLVMLessThanTest, SameStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "abC def", "abC def"); -} - -TEST_F(LLVMLessThanTest, SameStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "abC def", "abC def"); -} - -TEST_F(LLVMLessThanTest, StringsCaseDifferent) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "abC def", "abc dEf"); -} - -TEST_F(LLVMLessThanTest, StringsCaseDifferent_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "abC def", "abc dEf"); -} - -TEST_F(LLVMLessThanTest, FirstStringGreater) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMLessThanTest, FirstStringGreater_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMLessThanTest, SecondStringGreater) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "ghi Jkl", "abC def"); -} - -TEST_F(LLVMLessThanTest, SecondStringGreater_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "ghi Jkl", "abC def"); -} - -TEST_F(LLVMLessThanTest, StringsLengthComparison) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "abC def", "hello world"); -} - -TEST_F(LLVMLessThanTest, StringsLengthComparison_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "abC def", "hello world"); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, " ", ""); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, " ", ""); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, " ", "0"); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, " ", "0"); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, " ", 0); -} - -TEST_F(LLVMLessThanTest, SpaceGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, " ", 0); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, " "); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, " "); -} - -TEST_F(LLVMLessThanTest, EmptyGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "", "0"); -} - -TEST_F(LLVMLessThanTest, EmptyGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "", "0"); -} - -TEST_F(LLVMLessThanTest, EmptyGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "", 0); -} - -TEST_F(LLVMLessThanTest, EmptyGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "", 0); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, ""); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, ""); -} - -TEST_F(LLVMLessThanTest, ZeroStringGreaterThanZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "0", 0); -} - -TEST_F(LLVMLessThanTest, ZeroStringGreaterThanZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "0", 0); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "0"); -} - -TEST_F(LLVMLessThanTest, ZeroNumberGreaterThanZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "0"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.25, "5.25"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.25, "5.25"); -} - -TEST_F(LLVMLessThanTest, ExactStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "5.25", 5.25); -} - -TEST_F(LLVMLessThanTest, ExactStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "5.25", 5.25); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithLeadingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.25, " 5.25"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithLeadingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.25, " 5.25"); -} - -TEST_F(LLVMLessThanTest, StringWithLeadingSpaceGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, " 5.25", 5.25); -} - -TEST_F(LLVMLessThanTest, StringWithLeadingSpaceGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, " 5.25", 5.25); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithTrailingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.25, "5.25 "); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithTrailingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.25, "5.25 "); -} - -TEST_F(LLVMLessThanTest, StringWithTrailingSpaceGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "5.25 ", 5.25); -} - -TEST_F(LLVMLessThanTest, StringWithTrailingSpaceGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "5.25 ", 5.25); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithSurroundingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.25, " 5.25 "); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithSurroundingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.25, " 5.25 "); -} - -TEST_F(LLVMLessThanTest, StringWithSurroundingSpacesGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, " 5.25 ", 5.25); -} - -TEST_F(LLVMLessThanTest, StringWithSurroundingSpacesGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, " 5.25 ", 5.25); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanDifferentString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5.25, "5.26"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanDifferentString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5.25, "5.26"); -} - -TEST_F(LLVMLessThanTest, DifferentStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "5.26", 5.25); -} - -TEST_F(LLVMLessThanTest, DifferentStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "5.26", 5.25); -} - -TEST_F(LLVMLessThanTest, DifferentStringNumbers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "5.25", "5.26"); -} - -TEST_F(LLVMLessThanTest, DifferentStringNumbers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "5.25", "5.26"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithTrailingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5, "5 "); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanStringWithTrailingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5, "5 "); -} - -TEST_F(LLVMLessThanTest, StringWithTrailingSpacesGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "5 ", 5); -} - -TEST_F(LLVMLessThanTest, StringWithTrailingSpacesGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "5 ", 5); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "1"); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "1"); -} - -TEST_F(LLVMLessThanTest, OneStringGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "1", 0); -} - -TEST_F(LLVMLessThanTest, OneStringGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "1", 0); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "test"); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "test"); -} - -TEST_F(LLVMLessThanTest, TestStringGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "test", 0); -} - -TEST_F(LLVMLessThanTest, TestStringGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "test", 0); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanAbcString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 55, "abc"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanAbcString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 55, "abc"); -} - -TEST_F(LLVMLessThanTest, AbcStringGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "abc", 55); -} - -TEST_F(LLVMLessThanTest, AbcStringGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "abc", 55); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "NaN"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5, "Infinity"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5, "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", 5); -} - -TEST_F(LLVMLessThanTest, InfinityGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", 5); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", 5); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", 5); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 5, "NaN"); -} - -TEST_F(LLVMLessThanTest, NumberGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 5, "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", 5); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", 5); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "NaN"); -} - -TEST_F(LLVMLessThanTest, ZeroGreaterThanNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", 0); -} - -TEST_F(LLVMLessThanTest, NaNGreaterThanZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", 0); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "true"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "true"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", true); -} - -TEST_F(LLVMLessThanTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", true); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "false"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "false"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", false); -} - -TEST_F(LLVMLessThanTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", false); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "true"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "true"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", false); -} - -TEST_F(LLVMLessThanTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", false); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "false"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "false"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", true); -} - -TEST_F(LLVMLessThanTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", true); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "TRUE"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "TRUE"); -} - -TEST_F(LLVMLessThanTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "TRUE", true); -} - -TEST_F(LLVMLessThanTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "TRUE", true); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "FALSE"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "FALSE"); -} - -TEST_F(LLVMLessThanTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "FALSE", false); -} - -TEST_F(LLVMLessThanTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "FALSE", false); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "00001"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "00001"); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "00001", true); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "00001", true); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "00000"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "00000"); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "00000", true); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "00000", true); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "00000"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "00000"); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "00000", false); -} - -TEST_F(LLVMLessThanTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "00000", false); -} - -TEST_F(LLVMLessThanTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", 1); -} - -TEST_F(LLVMLessThanTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", 1); -} - -TEST_F(LLVMLessThanTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 1, "true"); -} - -TEST_F(LLVMLessThanTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 1, "true"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", 0); -} - -TEST_F(LLVMLessThanTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", 0); -} - -TEST_F(LLVMLessThanTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "true"); -} - -TEST_F(LLVMLessThanTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "true"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", 0); -} - -TEST_F(LLVMLessThanTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", 0); -} - -TEST_F(LLVMLessThanTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 0, "false"); -} - -TEST_F(LLVMLessThanTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 0, "false"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", 1); -} - -TEST_F(LLVMLessThanTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", 1); -} - -TEST_F(LLVMLessThanTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, 1, "false"); -} - -TEST_F(LLVMLessThanTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, 1, "false"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", "TRUE"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", "TRUE"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "true", "FALSE"); -} - -TEST_F(LLVMLessThanTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "true", "FALSE"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", "FALSE"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", "FALSE"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "false", "TRUE"); -} - -TEST_F(LLVMLessThanTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "false", "TRUE"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "Infinity"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", true); -} - -TEST_F(LLVMLessThanTest, InfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", true); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", true); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", true); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, true, "NaN"); -} - -TEST_F(LLVMLessThanTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, true, "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", true); -} - -TEST_F(LLVMLessThanTest, NaNWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", true); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "Infinity"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", false); -} - -TEST_F(LLVMLessThanTest, InfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", false); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", false); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", false); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, false, "NaN"); -} - -TEST_F(LLVMLessThanTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, false, "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", false); -} - -TEST_F(LLVMLessThanTest, NaNWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", false); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-infinity", "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "NaN"); -} - -TEST_F(LLVMLessThanTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "nan", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "nan", "Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "nan", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "nan", "-Infinity"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "nan", "NaN"); -} - -TEST_F(LLVMLessThanTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "nan", "NaN"); -} - -TEST_F(LLVMLessThanTest, InfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "abc"); -} - -TEST_F(LLVMLessThanTest, InfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "abc"); -} - -TEST_F(LLVMLessThanTest, InfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", " "); -} - -TEST_F(LLVMLessThanTest, InfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", " "); -} - -TEST_F(LLVMLessThanTest, InfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", ""); -} - -TEST_F(LLVMLessThanTest, InfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", ""); -} - -TEST_F(LLVMLessThanTest, InfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "Infinity", "0"); -} - -TEST_F(LLVMLessThanTest, InfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "Infinity", "0"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "abc"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "abc"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", " "); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", " "); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", ""); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", ""); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "-Infinity", "0"); -} - -TEST_F(LLVMLessThanTest, NegativeInfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "-Infinity", "0"); -} - -TEST_F(LLVMLessThanTest, NaNWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "abc"); -} - -TEST_F(LLVMLessThanTest, NaNWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "abc"); -} - -TEST_F(LLVMLessThanTest, NaNWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", " "); -} - -TEST_F(LLVMLessThanTest, NaNWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", " "); -} - -TEST_F(LLVMLessThanTest, NaNWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", ""); -} - -TEST_F(LLVMLessThanTest, NaNWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", ""); -} - -TEST_F(LLVMLessThanTest, NaNWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, false, "NaN", "0"); -} - -TEST_F(LLVMLessThanTest, NaNWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::CmpLT, true, "NaN", "0"); -} diff --git a/test/llvm/operators/logic/and_test.cpp b/test/llvm/operators/logic/and_test.cpp deleted file mode 100644 index 8129b2e82..000000000 --- a/test/llvm/operators/logic/and_test.cpp +++ /dev/null @@ -1,890 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAndTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAndTest, NumberWithNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 10, 8); -} - -TEST_F(LLVMAndTest, NumberWithNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 10, 8); -} - -TEST_F(LLVMAndTest, SameNegativeDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, -4.25, -4.25); -} - -TEST_F(LLVMAndTest, SameNegativeDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, -4.25, -4.25); -} - -TEST_F(LLVMAndTest, DifferentDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, -4.25, 5.312); -} - -TEST_F(LLVMAndTest, DifferentDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, -4.25, 5.312); -} - -TEST_F(LLVMAndTest, TrueAndTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, true); -} - -TEST_F(LLVMAndTest, TrueAndTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, true); -} - -TEST_F(LLVMAndTest, TrueAndFalse) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, false); -} - -TEST_F(LLVMAndTest, TrueAndFalse_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, false); -} - -TEST_F(LLVMAndTest, FalseAndTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, true); -} - -TEST_F(LLVMAndTest, FalseAndTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, true); -} - -TEST_F(LLVMAndTest, NumberAndTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 1, true); -} - -TEST_F(LLVMAndTest, NumberAndTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 1, true); -} - -TEST_F(LLVMAndTest, NumberAndFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 1, false); -} - -TEST_F(LLVMAndTest, NumberAndFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 1, false); -} - -TEST_F(LLVMAndTest, StringAndString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "abc", "def"); -} - -TEST_F(LLVMAndTest, StringAndString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "abc", "def"); -} - -TEST_F(LLVMAndTest, TrueStringAndTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", "true"); -} - -TEST_F(LLVMAndTest, TrueStringAndTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", "true"); -} - -TEST_F(LLVMAndTest, TrueStringAndFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", "false"); -} - -TEST_F(LLVMAndTest, TrueStringAndFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", "false"); -} - -TEST_F(LLVMAndTest, FalseStringAndTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", "true"); -} - -TEST_F(LLVMAndTest, FalseStringAndTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", "true"); -} - -TEST_F(LLVMAndTest, FalseStringAndFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", "false"); -} - -TEST_F(LLVMAndTest, FalseStringAndFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", "false"); -} - -TEST_F(LLVMAndTest, NumberAndExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 5.25, "5.25"); -} - -TEST_F(LLVMAndTest, NumberAndExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 5.25, "5.25"); -} - -TEST_F(LLVMAndTest, ExactStringAndNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "5.25", 5.25); -} - -TEST_F(LLVMAndTest, ExactStringAndNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "5.25", 5.25); -} - -TEST_F(LLVMAndTest, ZeroAndOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 0, "1"); -} - -TEST_F(LLVMAndTest, ZeroAndOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 0, "1"); -} - -TEST_F(LLVMAndTest, OneStringAndZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "1", 0); -} - -TEST_F(LLVMAndTest, OneStringAndZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "1", 0); -} - -TEST_F(LLVMAndTest, ZeroAndTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 0, "test"); -} - -TEST_F(LLVMAndTest, ZeroAndTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 0, "test"); -} - -TEST_F(LLVMAndTest, TestStringAndZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "test", 0); -} - -TEST_F(LLVMAndTest, TestStringAndZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "test", 0); -} - -TEST_F(LLVMAndTest, InfinityAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, NaNAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "NaN"); -} - -TEST_F(LLVMAndTest, NaNAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "NaN"); -} - -TEST_F(LLVMAndTest, InfinityAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, InfinityAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, InfinityAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NaNAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "Infinity"); -} - -TEST_F(LLVMAndTest, NaNAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NegativeInfinityAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NaNAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMAndTest, NaNAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "true"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "true"); -} - -TEST_F(LLVMAndTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", true); -} - -TEST_F(LLVMAndTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", true); -} - -TEST_F(LLVMAndTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "false"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "false"); -} - -TEST_F(LLVMAndTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", false); -} - -TEST_F(LLVMAndTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", false); -} - -TEST_F(LLVMAndTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "true"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "true"); -} - -TEST_F(LLVMAndTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", false); -} - -TEST_F(LLVMAndTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", false); -} - -TEST_F(LLVMAndTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "false"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "false"); -} - -TEST_F(LLVMAndTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", true); -} - -TEST_F(LLVMAndTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", true); -} - -TEST_F(LLVMAndTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "TRUE"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "TRUE"); -} - -TEST_F(LLVMAndTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "TRUE", true); -} - -TEST_F(LLVMAndTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "TRUE", true); -} - -TEST_F(LLVMAndTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "FALSE"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "FALSE"); -} - -TEST_F(LLVMAndTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "FALSE", false); -} - -TEST_F(LLVMAndTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "FALSE", false); -} - -TEST_F(LLVMAndTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "00001"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "00001"); -} - -TEST_F(LLVMAndTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "00001", true); -} - -TEST_F(LLVMAndTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "00001", true); -} - -TEST_F(LLVMAndTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "00000"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "00000"); -} - -TEST_F(LLVMAndTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "00000", true); -} - -TEST_F(LLVMAndTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "00000", true); -} - -TEST_F(LLVMAndTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "00000"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "00000"); -} - -TEST_F(LLVMAndTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "00000", false); -} - -TEST_F(LLVMAndTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "00000", false); -} - -TEST_F(LLVMAndTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", 1); -} - -TEST_F(LLVMAndTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", 1); -} - -TEST_F(LLVMAndTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 1, "true"); -} - -TEST_F(LLVMAndTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 1, "true"); -} - -TEST_F(LLVMAndTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", 0); -} - -TEST_F(LLVMAndTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", 0); -} - -TEST_F(LLVMAndTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 0, "true"); -} - -TEST_F(LLVMAndTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 0, "true"); -} - -TEST_F(LLVMAndTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", 0); -} - -TEST_F(LLVMAndTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", 0); -} - -TEST_F(LLVMAndTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 0, "false"); -} - -TEST_F(LLVMAndTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 0, "false"); -} - -TEST_F(LLVMAndTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", 1); -} - -TEST_F(LLVMAndTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", 1); -} - -TEST_F(LLVMAndTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, 1, "false"); -} - -TEST_F(LLVMAndTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, 1, "false"); -} - -TEST_F(LLVMAndTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", "TRUE"); -} - -TEST_F(LLVMAndTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", "TRUE"); -} - -TEST_F(LLVMAndTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "true", "FALSE"); -} - -TEST_F(LLVMAndTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "true", "FALSE"); -} - -TEST_F(LLVMAndTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", "FALSE"); -} - -TEST_F(LLVMAndTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", "FALSE"); -} - -TEST_F(LLVMAndTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "false", "TRUE"); -} - -TEST_F(LLVMAndTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "false", "TRUE"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "Infinity"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", true); -} - -TEST_F(LLVMAndTest, InfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", true); -} - -TEST_F(LLVMAndTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "-Infinity"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", true); -} - -TEST_F(LLVMAndTest, NegativeInfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", true); -} - -TEST_F(LLVMAndTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, true, "NaN"); -} - -TEST_F(LLVMAndTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, true, "NaN"); -} - -TEST_F(LLVMAndTest, NaNWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", true); -} - -TEST_F(LLVMAndTest, NaNWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", true); -} - -TEST_F(LLVMAndTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "Infinity"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", false); -} - -TEST_F(LLVMAndTest, InfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", false); -} - -TEST_F(LLVMAndTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "-Infinity"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", false); -} - -TEST_F(LLVMAndTest, NegativeInfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", false); -} - -TEST_F(LLVMAndTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, false, "NaN"); -} - -TEST_F(LLVMAndTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, false, "NaN"); -} - -TEST_F(LLVMAndTest, NaNWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", false); -} - -TEST_F(LLVMAndTest, NaNWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", false); -} - -TEST_F(LLVMAndTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "infinity", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "-infinity", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "-infinity", "NaN"); -} - -TEST_F(LLVMAndTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "Infinity"); -} - -TEST_F(LLVMAndTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "Infinity"); -} - -TEST_F(LLVMAndTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMAndTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMAndTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "NaN", "NaN"); -} - -TEST_F(LLVMAndTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "NaN", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "nan", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "nan", "Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "nan", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "nan", "-Infinity"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, false, "nan", "NaN"); -} - -TEST_F(LLVMAndTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::And, true, "nan", "NaN"); -} diff --git a/test/llvm/operators/logic/not_test.cpp b/test/llvm/operators/logic/not_test.cpp deleted file mode 100644 index 7c28e577c..000000000 --- a/test/llvm/operators/logic/not_test.cpp +++ /dev/null @@ -1,260 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMNotTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMNotTest, PositiveNumber) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, 10); -} - -TEST_F(LLVMNotTest, PositiveNumber_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, 10); -} - -TEST_F(LLVMNotTest, NegativeDecimal) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, -4.25); -} - -TEST_F(LLVMNotTest, NegativeDecimal_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, -4.25); -} - -TEST_F(LLVMNotTest, PositiveDecimal) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, 5.312); -} - -TEST_F(LLVMNotTest, PositiveDecimal_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, 5.312); -} - -TEST_F(LLVMNotTest, One) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, 1); -} - -TEST_F(LLVMNotTest, One_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, 1); -} - -TEST_F(LLVMNotTest, Zero) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, 0); -} - -TEST_F(LLVMNotTest, Zero_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, 0); -} - -TEST_F(LLVMNotTest, TrueBoolean) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, true); -} - -TEST_F(LLVMNotTest, TrueBoolean_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, true); -} - -TEST_F(LLVMNotTest, FalseBoolean) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, false); -} - -TEST_F(LLVMNotTest, FalseBoolean_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, false); -} - -TEST_F(LLVMNotTest, AbcString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "abc"); -} - -TEST_F(LLVMNotTest, AbcString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "abc"); -} - -TEST_F(LLVMNotTest, NumericString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "5.25"); -} - -TEST_F(LLVMNotTest, NumericString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "5.25"); -} - -TEST_F(LLVMNotTest, ZeroString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "0"); -} - -TEST_F(LLVMNotTest, ZeroString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "0"); -} - -TEST_F(LLVMNotTest, Infinity) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "Infinity"); -} - -TEST_F(LLVMNotTest, Infinity_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "Infinity"); -} - -TEST_F(LLVMNotTest, NegativeInfinity) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "-Infinity"); -} - -TEST_F(LLVMNotTest, NegativeInfinity_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "-Infinity"); -} - -TEST_F(LLVMNotTest, NaN) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "NaN"); -} - -TEST_F(LLVMNotTest, NaN_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "NaN"); -} - -TEST_F(LLVMNotTest, TrueString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "true"); -} - -TEST_F(LLVMNotTest, TrueString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "true"); -} - -TEST_F(LLVMNotTest, FalseString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "false"); -} - -TEST_F(LLVMNotTest, FalseString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "false"); -} - -TEST_F(LLVMNotTest, UppercaseTrueString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "TRUE"); -} - -TEST_F(LLVMNotTest, UppercaseTrueString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "TRUE"); -} - -TEST_F(LLVMNotTest, UppercaseFalseString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "FALSE"); -} - -TEST_F(LLVMNotTest, UppercaseFalseString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "FALSE"); -} - -TEST_F(LLVMNotTest, ZeroPaddedOne) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "00001"); -} - -TEST_F(LLVMNotTest, ZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "00001"); -} - -TEST_F(LLVMNotTest, ZeroPaddedZero) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "00000"); -} - -TEST_F(LLVMNotTest, ZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "00000"); -} - -TEST_F(LLVMNotTest, InfinityString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "Infinity"); -} - -TEST_F(LLVMNotTest, InfinityString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "Infinity"); -} - -TEST_F(LLVMNotTest, LowercaseInfinityString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "infinity"); -} - -TEST_F(LLVMNotTest, LowercaseInfinityString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "infinity"); -} - -TEST_F(LLVMNotTest, NegativeInfinityString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "-Infinity"); -} - -TEST_F(LLVMNotTest, NegativeInfinityString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "-Infinity"); -} - -TEST_F(LLVMNotTest, LowercaseNegativeInfinityString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "-infinity"); -} - -TEST_F(LLVMNotTest, LowercaseNegativeInfinityString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "-infinity"); -} - -TEST_F(LLVMNotTest, NaNString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "NaN"); -} - -TEST_F(LLVMNotTest, NaNString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "NaN"); -} - -TEST_F(LLVMNotTest, LowercaseNaNString) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, false, "nan"); -} - -TEST_F(LLVMNotTest, LowercaseNaNString_Const) -{ - ASSERT_BOOL_OP1(m_utils, LLVMTestUtils::OpType::Not, true, "nan"); -} diff --git a/test/llvm/operators/logic/or_test.cpp b/test/llvm/operators/logic/or_test.cpp deleted file mode 100644 index f16510c54..000000000 --- a/test/llvm/operators/logic/or_test.cpp +++ /dev/null @@ -1,890 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMOrTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMOrTest, NumberWithNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 10, 8); -} - -TEST_F(LLVMOrTest, NumberWithNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 10, 8); -} - -TEST_F(LLVMOrTest, SameNegativeDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, -4.25, -4.25); -} - -TEST_F(LLVMOrTest, SameNegativeDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, -4.25, -4.25); -} - -TEST_F(LLVMOrTest, DifferentDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, -4.25, 5.312); -} - -TEST_F(LLVMOrTest, DifferentDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, -4.25, 5.312); -} - -TEST_F(LLVMOrTest, TrueAndTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, true); -} - -TEST_F(LLVMOrTest, TrueAndTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, true); -} - -TEST_F(LLVMOrTest, TrueAndFalse) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, false); -} - -TEST_F(LLVMOrTest, TrueAndFalse_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, false); -} - -TEST_F(LLVMOrTest, FalseAndTrue) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, true); -} - -TEST_F(LLVMOrTest, FalseAndTrue_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, true); -} - -TEST_F(LLVMOrTest, NumberAndTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 1, true); -} - -TEST_F(LLVMOrTest, NumberAndTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 1, true); -} - -TEST_F(LLVMOrTest, NumberAndFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 1, false); -} - -TEST_F(LLVMOrTest, NumberAndFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 1, false); -} - -TEST_F(LLVMOrTest, StringAndString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "abc", "def"); -} - -TEST_F(LLVMOrTest, StringAndString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "abc", "def"); -} - -TEST_F(LLVMOrTest, TrueStringAndTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", "true"); -} - -TEST_F(LLVMOrTest, TrueStringAndTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", "true"); -} - -TEST_F(LLVMOrTest, TrueStringAndFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", "false"); -} - -TEST_F(LLVMOrTest, TrueStringAndFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", "false"); -} - -TEST_F(LLVMOrTest, FalseStringAndTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", "true"); -} - -TEST_F(LLVMOrTest, FalseStringAndTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", "true"); -} - -TEST_F(LLVMOrTest, FalseStringAndFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", "false"); -} - -TEST_F(LLVMOrTest, FalseStringAndFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", "false"); -} - -TEST_F(LLVMOrTest, NumberAndExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 5.25, "5.25"); -} - -TEST_F(LLVMOrTest, NumberAndExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 5.25, "5.25"); -} - -TEST_F(LLVMOrTest, ExactStringAndNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "5.25", 5.25); -} - -TEST_F(LLVMOrTest, ExactStringAndNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "5.25", 5.25); -} - -TEST_F(LLVMOrTest, ZeroAndOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 0, "1"); -} - -TEST_F(LLVMOrTest, ZeroAndOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 0, "1"); -} - -TEST_F(LLVMOrTest, OneStringAndZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "1", 0); -} - -TEST_F(LLVMOrTest, OneStringAndZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "1", 0); -} - -TEST_F(LLVMOrTest, ZeroAndTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 0, "test"); -} - -TEST_F(LLVMOrTest, ZeroAndTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 0, "test"); -} - -TEST_F(LLVMOrTest, TestStringAndZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "test", 0); -} - -TEST_F(LLVMOrTest, TestStringAndZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "test", 0); -} - -TEST_F(LLVMOrTest, InfinityAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, NaNAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "NaN"); -} - -TEST_F(LLVMOrTest, NaNAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "NaN"); -} - -TEST_F(LLVMOrTest, InfinityAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, InfinityAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, InfinityAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NaNAndInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "Infinity"); -} - -TEST_F(LLVMOrTest, NaNAndInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NegativeInfinityAndNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NaNAndNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMOrTest, NaNAndNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "true"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "true"); -} - -TEST_F(LLVMOrTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", true); -} - -TEST_F(LLVMOrTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", true); -} - -TEST_F(LLVMOrTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "false"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "false"); -} - -TEST_F(LLVMOrTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", false); -} - -TEST_F(LLVMOrTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", false); -} - -TEST_F(LLVMOrTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "true"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "true"); -} - -TEST_F(LLVMOrTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", false); -} - -TEST_F(LLVMOrTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", false); -} - -TEST_F(LLVMOrTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "false"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "false"); -} - -TEST_F(LLVMOrTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", true); -} - -TEST_F(LLVMOrTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", true); -} - -TEST_F(LLVMOrTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "TRUE"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "TRUE"); -} - -TEST_F(LLVMOrTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "TRUE", true); -} - -TEST_F(LLVMOrTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "TRUE", true); -} - -TEST_F(LLVMOrTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "FALSE"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "FALSE"); -} - -TEST_F(LLVMOrTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "FALSE", false); -} - -TEST_F(LLVMOrTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "FALSE", false); -} - -TEST_F(LLVMOrTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "00001"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "00001"); -} - -TEST_F(LLVMOrTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "00001", true); -} - -TEST_F(LLVMOrTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "00001", true); -} - -TEST_F(LLVMOrTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "00000"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "00000"); -} - -TEST_F(LLVMOrTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "00000", true); -} - -TEST_F(LLVMOrTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "00000", true); -} - -TEST_F(LLVMOrTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "00000"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "00000"); -} - -TEST_F(LLVMOrTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "00000", false); -} - -TEST_F(LLVMOrTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "00000", false); -} - -TEST_F(LLVMOrTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", 1); -} - -TEST_F(LLVMOrTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", 1); -} - -TEST_F(LLVMOrTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 1, "true"); -} - -TEST_F(LLVMOrTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 1, "true"); -} - -TEST_F(LLVMOrTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", 0); -} - -TEST_F(LLVMOrTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", 0); -} - -TEST_F(LLVMOrTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 0, "true"); -} - -TEST_F(LLVMOrTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 0, "true"); -} - -TEST_F(LLVMOrTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", 0); -} - -TEST_F(LLVMOrTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", 0); -} - -TEST_F(LLVMOrTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 0, "false"); -} - -TEST_F(LLVMOrTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 0, "false"); -} - -TEST_F(LLVMOrTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", 1); -} - -TEST_F(LLVMOrTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", 1); -} - -TEST_F(LLVMOrTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, 1, "false"); -} - -TEST_F(LLVMOrTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, 1, "false"); -} - -TEST_F(LLVMOrTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", "TRUE"); -} - -TEST_F(LLVMOrTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", "TRUE"); -} - -TEST_F(LLVMOrTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "true", "FALSE"); -} - -TEST_F(LLVMOrTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "true", "FALSE"); -} - -TEST_F(LLVMOrTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", "FALSE"); -} - -TEST_F(LLVMOrTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", "FALSE"); -} - -TEST_F(LLVMOrTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "false", "TRUE"); -} - -TEST_F(LLVMOrTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "false", "TRUE"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "Infinity"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", true); -} - -TEST_F(LLVMOrTest, InfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", true); -} - -TEST_F(LLVMOrTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "-Infinity"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", true); -} - -TEST_F(LLVMOrTest, NegativeInfinityWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", true); -} - -TEST_F(LLVMOrTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, true, "NaN"); -} - -TEST_F(LLVMOrTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, true, "NaN"); -} - -TEST_F(LLVMOrTest, NaNWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", true); -} - -TEST_F(LLVMOrTest, NaNWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", true); -} - -TEST_F(LLVMOrTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "Infinity"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", false); -} - -TEST_F(LLVMOrTest, InfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", false); -} - -TEST_F(LLVMOrTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "-Infinity"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", false); -} - -TEST_F(LLVMOrTest, NegativeInfinityWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", false); -} - -TEST_F(LLVMOrTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, false, "NaN"); -} - -TEST_F(LLVMOrTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, false, "NaN"); -} - -TEST_F(LLVMOrTest, NaNWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", false); -} - -TEST_F(LLVMOrTest, NaNWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", false); -} - -TEST_F(LLVMOrTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "infinity", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "-infinity", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "-infinity", "NaN"); -} - -TEST_F(LLVMOrTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "Infinity"); -} - -TEST_F(LLVMOrTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "Infinity"); -} - -TEST_F(LLVMOrTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMOrTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMOrTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "NaN", "NaN"); -} - -TEST_F(LLVMOrTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "NaN", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "nan", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "nan", "Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "nan", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "nan", "-Infinity"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, false, "nan", "NaN"); -} - -TEST_F(LLVMOrTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::Or, true, "nan", "NaN"); -} diff --git a/test/llvm/operators/math/abs_test.cpp b/test/llvm/operators/math/abs_test.cpp deleted file mode 100644 index 1c49ace13..000000000 --- a/test/llvm/operators/math/abs_test.cpp +++ /dev/null @@ -1,116 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAbsTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAbsTest, PositiveFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMAbsTest, PositiveFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMAbsTest, PositiveDecimal) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, 3.2).toDouble(), 3.2); -} - -TEST_F(LLVMAbsTest, PositiveDecimal_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, 3.2).toDouble(), 3.2); -} - -TEST_F(LLVMAbsTest, NegativeTwo) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, -2.0).toDouble(), 2.0); -} - -TEST_F(LLVMAbsTest, NegativeTwo_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, -2.0).toDouble(), 2.0); -} - -TEST_F(LLVMAbsTest, NegativeDecimalTwoPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, -2.5).toDouble(), 2.5); -} - -TEST_F(LLVMAbsTest, NegativeDecimalTwoPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, -2.5).toDouble(), 2.5); -} - -TEST_F(LLVMAbsTest, NegativeDecimalTwoPointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, -2.6).toDouble(), 2.6); -} - -TEST_F(LLVMAbsTest, NegativeDecimalTwoPointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, -2.6).toDouble(), 2.6); -} - -TEST_F(LLVMAbsTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAbsTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAbsTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAbsTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAbsTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, inf).toDouble(), inf); -} - -TEST_F(LLVMAbsTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, inf).toDouble(), inf); -} - -TEST_F(LLVMAbsTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, -inf).toDouble(), inf); -} - -TEST_F(LLVMAbsTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, -inf).toDouble(), inf); -} - -TEST_F(LLVMAbsTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, false, nan).toDouble(), 0); -} - -TEST_F(LLVMAbsTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Abs, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/acos_test.cpp b/test/llvm/operators/math/acos_test.cpp deleted file mode 100644 index dec02caf6..000000000 --- a/test/llvm/operators/math/acos_test.cpp +++ /dev/null @@ -1,126 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAcosTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAcosTest, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, 1.0).toDouble(), 0.0); -} - -TEST_F(LLVMAcosTest, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, 1.0).toDouble(), 0.0); -} - -TEST_F(LLVMAcosTest, OneHalf) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, 0.5).toDouble() * 100) / 100, 60.0); -} - -TEST_F(LLVMAcosTest, OneHalf_Const) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, 0.5).toDouble() * 100) / 100, 60.0); -} - -TEST_F(LLVMAcosTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, 0.0).toDouble(), 90.0); -} - -TEST_F(LLVMAcosTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, 0.0).toDouble(), 90.0); -} - -TEST_F(LLVMAcosTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, -0.0).toDouble(), 90.0); -} - -TEST_F(LLVMAcosTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, -0.0).toDouble(), 90.0); -} - -TEST_F(LLVMAcosTest, NegativeOneHalf) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, -0.5).toDouble() * 100) / 100, 120.0); -} - -TEST_F(LLVMAcosTest, NegativeOneHalf_Const) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, -0.5).toDouble() * 100) / 100, 120.0); -} - -TEST_F(LLVMAcosTest, NegativeOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, -1.0).toDouble(), 180.0); -} - -TEST_F(LLVMAcosTest, NegativeOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, -1.0).toDouble(), 180.0); -} - -TEST_F(LLVMAcosTest, OutOfRangePositive) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, 1.1).isNaN()); -} - -TEST_F(LLVMAcosTest, OutOfRangePositive_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, 1.1).isNaN()); -} - -TEST_F(LLVMAcosTest, OutOfRangeNegative) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, -1.2).isNaN()); -} - -TEST_F(LLVMAcosTest, OutOfRangeNegative_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, -1.2).isNaN()); -} - -TEST_F(LLVMAcosTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, inf).isNaN()); -} - -TEST_F(LLVMAcosTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, inf).isNaN()); -} - -TEST_F(LLVMAcosTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, -inf).isNaN()); -} - -TEST_F(LLVMAcosTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, -inf).isNaN()); -} - -TEST_F(LLVMAcosTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, false, nan).toDouble(), 90.0); -} - -TEST_F(LLVMAcosTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Acos, true, nan).toDouble(), 90.0); -} diff --git a/test/llvm/operators/math/add_test.cpp b/test/llvm/operators/math/add_test.cpp deleted file mode 100644 index 5fb706fe5..000000000 --- a/test/llvm/operators/math/add_test.cpp +++ /dev/null @@ -1,130 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAddTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAddTest, PositiveIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, 50, 25); -} - -TEST_F(LLVMAddTest, PositiveIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, 50, 25); -} - -TEST_F(LLVMAddTest, NegativeWithPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, -500, 25); -} - -TEST_F(LLVMAddTest, NegativeWithPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, -500, 25); -} - -TEST_F(LLVMAddTest, NegativeIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, -500, -25); -} - -TEST_F(LLVMAddTest, NegativeIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, -500, -25); -} - -TEST_F(LLVMAddTest, StringDecimals) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "2.54", "6.28"); -} - -TEST_F(LLVMAddTest, StringDecimals_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "2.54", "6.28"); -} - -TEST_F(LLVMAddTest, MixedDecimalAndString) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, 2.54, "-6.28"); -} - -TEST_F(LLVMAddTest, MixedDecimalAndString_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, 2.54, "-6.28"); -} - -TEST_F(LLVMAddTest, BooleanValues) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, true, true); -} - -TEST_F(LLVMAddTest, BooleanValues_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, true, true); -} - -TEST_F(LLVMAddTest, InfinityPlusInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMAddTest, InfinityPlusInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMAddTest, InfinityPlusNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAddTest, InfinityPlusNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMAddTest, NegativeInfinityPlusInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAddTest, NegativeInfinityPlusInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMAddTest, NegativeInfinityPlusNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAddTest, NegativeInfinityPlusNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMAddTest, NumberPlusNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, 1, "NaN"); -} - -TEST_F(LLVMAddTest, NumberPlusNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, 1, "NaN"); -} - -TEST_F(LLVMAddTest, NaNPlusNumber) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, false, "NaN", 1); -} - -TEST_F(LLVMAddTest, NaNPlusNumber_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Add, true, "NaN", 1); -} diff --git a/test/llvm/operators/math/asin_test.cpp b/test/llvm/operators/math/asin_test.cpp deleted file mode 100644 index 7ecf9daf3..000000000 --- a/test/llvm/operators/math/asin_test.cpp +++ /dev/null @@ -1,126 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAsinTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAsinTest, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, 1.0).toDouble(), 90.0); -} - -TEST_F(LLVMAsinTest, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, 1.0).toDouble(), 90.0); -} - -TEST_F(LLVMAsinTest, OneHalf) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, 0.5).toDouble() * 100) / 100, 30.0); -} - -TEST_F(LLVMAsinTest, OneHalf_Const) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, 0.5).toDouble() * 100) / 100, 30.0); -} - -TEST_F(LLVMAsinTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAsinTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAsinTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAsinTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAsinTest, NegativeOneHalf) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, -0.5).toDouble() * 100) / 100, -30.0); -} - -TEST_F(LLVMAsinTest, NegativeOneHalf_Const) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, -0.5).toDouble() * 100) / 100, -30.0); -} - -TEST_F(LLVMAsinTest, NegativeOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, -1.0).toDouble(), -90.0); -} - -TEST_F(LLVMAsinTest, NegativeOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, -1.0).toDouble(), -90.0); -} - -TEST_F(LLVMAsinTest, OutOfRangePositive) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, 1.1).isNaN()); -} - -TEST_F(LLVMAsinTest, OutOfRangePositive_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, 1.1).isNaN()); -} - -TEST_F(LLVMAsinTest, OutOfRangeNegative) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, -1.2).isNaN()); -} - -TEST_F(LLVMAsinTest, OutOfRangeNegative_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, -1.2).isNaN()); -} - -TEST_F(LLVMAsinTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, inf).isNaN()); -} - -TEST_F(LLVMAsinTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, inf).isNaN()); -} - -TEST_F(LLVMAsinTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, -inf).isNaN()); -} - -TEST_F(LLVMAsinTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, -inf).isNaN()); -} - -TEST_F(LLVMAsinTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, false, nan).toDouble(), 0.0); -} - -TEST_F(LLVMAsinTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Asin, true, nan).toDouble(), 0.0); -} diff --git a/test/llvm/operators/math/atan_test.cpp b/test/llvm/operators/math/atan_test.cpp deleted file mode 100644 index e6b983777..000000000 --- a/test/llvm/operators/math/atan_test.cpp +++ /dev/null @@ -1,86 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMAtanTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMAtanTest, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, 1.0).toDouble(), 45.0); -} - -TEST_F(LLVMAtanTest, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, 1.0).toDouble(), 45.0); -} - -TEST_F(LLVMAtanTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAtanTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMAtanTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMAtanTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMAtanTest, NegativeOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, -1.0).toDouble(), -45.0); -} - -TEST_F(LLVMAtanTest, NegativeOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, -1.0).toDouble(), -45.0); -} - -TEST_F(LLVMAtanTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, inf).toDouble(), 90.0); -} - -TEST_F(LLVMAtanTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, inf).toDouble(), 90.0); -} - -TEST_F(LLVMAtanTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, -inf).toDouble(), -90.0); -} - -TEST_F(LLVMAtanTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, -inf).toDouble(), -90.0); -} - -TEST_F(LLVMAtanTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, false, nan).toDouble(), 0.0); -} - -TEST_F(LLVMAtanTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Atan, true, nan).toDouble(), 0.0); -} diff --git a/test/llvm/operators/math/ceil_test.cpp b/test/llvm/operators/math/ceil_test.cpp deleted file mode 100644 index 4537c76f1..000000000 --- a/test/llvm/operators/math/ceil_test.cpp +++ /dev/null @@ -1,176 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMCeilTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMCeilTest, EightPointZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 8.0).toDouble(), 8.0); -} - -TEST_F(LLVMCeilTest, EightPointZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 8.0).toDouble(), 8.0); -} - -TEST_F(LLVMCeilTest, ThreePointTwo) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 3.2).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ThreePointTwo_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 3.2).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ThreePointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 3.5).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ThreePointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 3.5).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ThreePointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 3.6).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ThreePointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 3.6).toDouble(), 4.0); -} - -TEST_F(LLVMCeilTest, ZeroPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 0.4).toDouble(), 1.0); -} - -TEST_F(LLVMCeilTest, ZeroPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 0.4).toDouble(), 1.0); -} - -TEST_F(LLVMCeilTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMCeilTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMCeilTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -2.4).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -2.4).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -2.5).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -2.5).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -2.6).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeTwoPointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -2.6).toDouble(), -2.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -0.4).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -0.4).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -0.5).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -0.5).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFiftyOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -0.51).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, NegativeZeroPointFiftyOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -0.51).toDouble(), -0.0); -} - -TEST_F(LLVMCeilTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, inf).toDouble(), inf); -} - -TEST_F(LLVMCeilTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, inf).toDouble(), inf); -} - -TEST_F(LLVMCeilTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, -inf).toDouble(), -inf); -} - -TEST_F(LLVMCeilTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, -inf).toDouble(), -inf); -} - -TEST_F(LLVMCeilTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, false, nan).toDouble(), 0); -} - -TEST_F(LLVMCeilTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ceil, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/cos_test.cpp b/test/llvm/operators/math/cos_test.cpp deleted file mode 100644 index 0b5daf305..000000000 --- a/test/llvm/operators/math/cos_test.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMCosTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMCosTest, SixtyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 60.0).toDouble(), 0.5); -} - -TEST_F(LLVMCosTest, SixtyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 60.0).toDouble(), 0.5); -} - -TEST_F(LLVMCosTest, NinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 90.0).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, NinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 90.0).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, SixHundredDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 600.0).toDouble(), -0.5); -} - -TEST_F(LLVMCosTest, SixHundredDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 600.0).toDouble(), -0.5); -} - -TEST_F(LLVMCosTest, AlmostNinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 89.9999999971352).toDouble(), 1e-10); -} - -TEST_F(LLVMCosTest, AlmostNinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 89.9999999971352).toDouble(), 1e-10); -} - -TEST_F(LLVMCosTest, VeryCloseToNinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 89.999999999).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, VeryCloseToNinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 89.999999999).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, NegativeSixtyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, -60.0).toDouble(), 0.5); -} - -TEST_F(LLVMCosTest, NegativeSixtyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, -60.0).toDouble(), 0.5); -} - -TEST_F(LLVMCosTest, NegativeNinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, -90.0).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, NegativeNinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, -90.0).toDouble(), 0.0); -} - -TEST_F(LLVMCosTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMCosTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMCosTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMCosTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMCosTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, inf).isNaN()); -} - -TEST_F(LLVMCosTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, inf).isNaN()); -} - -TEST_F(LLVMCosTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, -inf).isNaN()); -} - -TEST_F(LLVMCosTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, -inf).isNaN()); -} - -TEST_F(LLVMCosTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, false, nan).toDouble(), 1.0); -} - -TEST_F(LLVMCosTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Cos, true, nan).toDouble(), 1.0); -} diff --git a/test/llvm/operators/math/divide_test.cpp b/test/llvm/operators/math/divide_test.cpp deleted file mode 100644 index 91e327d45..000000000 --- a/test/llvm/operators/math/divide_test.cpp +++ /dev/null @@ -1,270 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMDivideTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMDivideTest, PositiveIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 50, 2); -} - -TEST_F(LLVMDivideTest, PositiveIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 50, 2); -} - -TEST_F(LLVMDivideTest, NegativeWithPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, -500, 25); -} - -TEST_F(LLVMDivideTest, NegativeWithPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, -500, 25); -} - -TEST_F(LLVMDivideTest, StringNegativeWithNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-500", -25); -} - -TEST_F(LLVMDivideTest, StringNegativeWithNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-500", -25); -} - -TEST_F(LLVMDivideTest, StringDecimals) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "3.5", "2.5"); -} - -TEST_F(LLVMDivideTest, StringDecimals_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "3.5", "2.5"); -} - -TEST_F(LLVMDivideTest, BooleanValues) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, true, true); -} - -TEST_F(LLVMDivideTest, BooleanValues_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, true, true); -} - -TEST_F(LLVMDivideTest, InfinityDividedByInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMDivideTest, InfinityDividedByInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMDivideTest, InfinityDividedByZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "Infinity", 0); -} - -TEST_F(LLVMDivideTest, InfinityDividedByZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "Infinity", 0); -} - -TEST_F(LLVMDivideTest, InfinityDividedByPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "Infinity", 2); -} - -TEST_F(LLVMDivideTest, InfinityDividedByPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "Infinity", 2); -} - -TEST_F(LLVMDivideTest, InfinityDividedByNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "Infinity", -2); -} - -TEST_F(LLVMDivideTest, InfinityDividedByNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "Infinity", -2); -} - -TEST_F(LLVMDivideTest, InfinityDividedByNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMDivideTest, InfinityDividedByNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-Infinity", 0); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-Infinity", 0); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-Infinity", 2); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-Infinity", 2); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-Infinity", -2); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-Infinity", -2); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeInfinityDividedByNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMDivideTest, ZeroDividedByInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 0, "Infinity"); -} - -TEST_F(LLVMDivideTest, ZeroDividedByInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 0, "Infinity"); -} - -TEST_F(LLVMDivideTest, PositiveDividedByInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 2, "Infinity"); -} - -TEST_F(LLVMDivideTest, PositiveDividedByInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 2, "Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeDividedByInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, -2, "Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeDividedByInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, -2, "Infinity"); -} - -TEST_F(LLVMDivideTest, ZeroDividedByNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 0, "-Infinity"); -} - -TEST_F(LLVMDivideTest, ZeroDividedByNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 0, "-Infinity"); -} - -TEST_F(LLVMDivideTest, PositiveDividedByNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 2, "-Infinity"); -} - -TEST_F(LLVMDivideTest, PositiveDividedByNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 2, "-Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeDividedByNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, -2, "-Infinity"); -} - -TEST_F(LLVMDivideTest, NegativeDividedByNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, -2, "-Infinity"); -} - -TEST_F(LLVMDivideTest, NumberDividedByNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 1, "NaN"); -} - -TEST_F(LLVMDivideTest, NumberDividedByNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 1, "NaN"); -} - -TEST_F(LLVMDivideTest, NaNDividedByNumber) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, "NaN", 1); -} - -TEST_F(LLVMDivideTest, NaNDividedByNumber_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, "NaN", 1); -} - -TEST_F(LLVMDivideTest, PositiveDividedByZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 5, 0); -} - -TEST_F(LLVMDivideTest, PositiveDividedByZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 5, 0); -} - -TEST_F(LLVMDivideTest, NegativeDividedByZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, -5, 0); -} - -TEST_F(LLVMDivideTest, NegativeDividedByZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, -5, 0); -} - -TEST_F(LLVMDivideTest, ZeroDividedByZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, false, 0, 0); -} - -TEST_F(LLVMDivideTest, ZeroDividedByZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Div, true, 0, 0); -} diff --git a/test/llvm/operators/math/exp10_test.cpp b/test/llvm/operators/math/exp10_test.cpp deleted file mode 100644 index b7ff6a255..000000000 --- a/test/llvm/operators/math/exp10_test.cpp +++ /dev/null @@ -1,106 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMExp10Test : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMExp10Test, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, 1.0).toDouble(), 10.0); -} - -TEST_F(LLVMExp10Test, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, 1.0).toDouble(), 10.0); -} - -TEST_F(LLVMExp10Test, Three) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, 3.0).toDouble(), 1000.0); -} - -TEST_F(LLVMExp10Test, Three_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, 3.0).toDouble(), 1000.0); -} - -TEST_F(LLVMExp10Test, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExp10Test, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExp10Test, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExp10Test, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExp10Test, NegativeOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, -1.0).toDouble(), 0.1); -} - -TEST_F(LLVMExp10Test, NegativeOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, -1.0).toDouble(), 0.1); -} - -TEST_F(LLVMExp10Test, NegativeFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, -5.0).toDouble(), 0.00001); -} - -TEST_F(LLVMExp10Test, NegativeFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, -5.0).toDouble(), 0.00001); -} - -TEST_F(LLVMExp10Test, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, inf).toDouble(), inf); -} - -TEST_F(LLVMExp10Test, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, inf).toDouble(), inf); -} - -TEST_F(LLVMExp10Test, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, -inf).toDouble(), 0.0); -} - -TEST_F(LLVMExp10Test, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, -inf).toDouble(), 0.0); -} - -TEST_F(LLVMExp10Test, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, false, nan).toDouble(), 1.0); -} - -TEST_F(LLVMExp10Test, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp10, true, nan).toDouble(), 1.0); -} diff --git a/test/llvm/operators/math/exp_test.cpp b/test/llvm/operators/math/exp_test.cpp deleted file mode 100644 index 52fc6ecff..000000000 --- a/test/llvm/operators/math/exp_test.cpp +++ /dev/null @@ -1,96 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMExpTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMExpTest, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, 1.0).toDouble(), std::exp(1.0)); -} - -TEST_F(LLVMExpTest, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, 1.0).toDouble(), std::exp(1.0)); -} - -TEST_F(LLVMExpTest, ZeroPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, 0.5).toDouble(), std::exp(0.5)); -} - -TEST_F(LLVMExpTest, ZeroPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, 0.5).toDouble(), std::exp(0.5)); -} - -TEST_F(LLVMExpTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExpTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, 0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExpTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExpTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, -0.0).toDouble(), 1.0); -} - -TEST_F(LLVMExpTest, NegativeZeroPointSeven) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, -0.7).toDouble(), std::exp(-0.7)); -} - -TEST_F(LLVMExpTest, NegativeZeroPointSeven_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, -0.7).toDouble(), std::exp(-0.7)); -} - -TEST_F(LLVMExpTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, inf).toDouble(), inf); -} - -TEST_F(LLVMExpTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, inf).toDouble(), inf); -} - -TEST_F(LLVMExpTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, -inf).toDouble(), 0.0); -} - -TEST_F(LLVMExpTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, -inf).toDouble(), 0.0); -} - -TEST_F(LLVMExpTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, false, nan).toDouble(), 1.0); -} - -TEST_F(LLVMExpTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Exp, true, nan).toDouble(), 1.0); -} diff --git a/test/llvm/operators/math/floor_test.cpp b/test/llvm/operators/math/floor_test.cpp deleted file mode 100644 index 8329bd02b..000000000 --- a/test/llvm/operators/math/floor_test.cpp +++ /dev/null @@ -1,166 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMFloorTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMFloorTest, FourPointZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMFloorTest, FourPointZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMFloorTest, ThreePointTwo) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, 3.2).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, ThreePointTwo_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, 3.2).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, ThreePointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, 3.5).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, ThreePointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, 3.5).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, ThreePointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, 3.6).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, ThreePointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, 3.6).toDouble(), 3.0); -} - -TEST_F(LLVMFloorTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMFloorTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMFloorTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMFloorTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -0.0).toDouble(), -0.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -2.4).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -2.4).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -2.5).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -2.5).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -2.6).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeTwoPointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -2.6).toDouble(), -3.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -0.4).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -0.4).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -0.5).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -0.5).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFiftyOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -0.51).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, NegativeZeroPointFiftyOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -0.51).toDouble(), -1.0); -} - -TEST_F(LLVMFloorTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, inf).toDouble(), inf); -} - -TEST_F(LLVMFloorTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, inf).toDouble(), inf); -} - -TEST_F(LLVMFloorTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, -inf).toDouble(), -inf); -} - -TEST_F(LLVMFloorTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, -inf).toDouble(), -inf); -} - -TEST_F(LLVMFloorTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, false, nan).toDouble(), 0); -} - -TEST_F(LLVMFloorTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Floor, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/ln_test.cpp b/test/llvm/operators/math/ln_test.cpp deleted file mode 100644 index 1a6763fa0..000000000 --- a/test/llvm/operators/math/ln_test.cpp +++ /dev/null @@ -1,122 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMLnTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMLnTest, ExpOfOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, std::exp(1.0)).toDouble(), 1.0); -} - -TEST_F(LLVMLnTest, ExpOfOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, std::exp(1.0)).toDouble(), 1.0); -} - -TEST_F(LLVMLnTest, ExpOfTwo) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, std::exp(2.0)).toDouble(), 2.0); -} - -TEST_F(LLVMLnTest, ExpOfTwo_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, std::exp(2.0)).toDouble(), 2.0); -} - -TEST_F(LLVMLnTest, ExpOfZeroPointThree) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, std::exp(0.3)).toDouble() * 100) / 100, 0.3); -} - -TEST_F(LLVMLnTest, ExpOfZeroPointThree_Const) -{ - ASSERT_EQ(std::round(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, std::exp(0.3)).toDouble() * 100) / 100, 0.3); -} - -TEST_F(LLVMLnTest, One) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, 1.0).toDouble(), 0.0); -} - -TEST_F(LLVMLnTest, One_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, 1.0).toDouble(), 0.0); -} - -TEST_F(LLVMLnTest, PositiveZero) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, 0.0).toDouble(), -inf); -} - -TEST_F(LLVMLnTest, PositiveZero_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, 0.0).toDouble(), -inf); -} - -TEST_F(LLVMLnTest, NegativeZero) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, -0.0).toDouble(), -inf); -} - -TEST_F(LLVMLnTest, NegativeZero_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, -0.0).toDouble(), -inf); -} - -TEST_F(LLVMLnTest, NegativeNumber) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, -0.7).isNaN()); -} - -TEST_F(LLVMLnTest, NegativeNumber_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, -0.7).isNaN()); -} - -TEST_F(LLVMLnTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, inf).toDouble(), inf); -} - -TEST_F(LLVMLnTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, inf).toDouble(), inf); -} - -TEST_F(LLVMLnTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, -inf).isNaN()); -} - -TEST_F(LLVMLnTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, -inf).isNaN()); -} - -TEST_F(LLVMLnTest, NaN) -{ - static const double inf = std::numeric_limits::infinity(); - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, false, nan).toDouble(), -inf); -} - -TEST_F(LLVMLnTest, NaN_Const) -{ - static const double inf = std::numeric_limits::infinity(); - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Ln, true, nan).toDouble(), -inf); -} diff --git a/test/llvm/operators/math/log10_test.cpp b/test/llvm/operators/math/log10_test.cpp deleted file mode 100644 index 3b021f13e..000000000 --- a/test/llvm/operators/math/log10_test.cpp +++ /dev/null @@ -1,112 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMLog10Test : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMLog10Test, Ten) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, 10.0).toDouble(), 1.0); -} - -TEST_F(LLVMLog10Test, Ten_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, 10.0).toDouble(), 1.0); -} - -TEST_F(LLVMLog10Test, OneThousand) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, 1000.0).toDouble(), 3.0); -} - -TEST_F(LLVMLog10Test, OneThousand_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, 1000.0).toDouble(), 3.0); -} - -TEST_F(LLVMLog10Test, ZeroPointZeroOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, 0.01).toDouble(), -2.0); -} - -TEST_F(LLVMLog10Test, ZeroPointZeroOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, 0.01).toDouble(), -2.0); -} - -TEST_F(LLVMLog10Test, PositiveZero) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, 0.0).toDouble(), -inf); -} - -TEST_F(LLVMLog10Test, PositiveZero_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, 0.0).toDouble(), -inf); -} - -TEST_F(LLVMLog10Test, NegativeZero) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, -0.0).toDouble(), -inf); -} - -TEST_F(LLVMLog10Test, NegativeZero_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, -0.0).toDouble(), -inf); -} - -TEST_F(LLVMLog10Test, NegativeNumber) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, -0.7).isNaN()); -} - -TEST_F(LLVMLog10Test, NegativeNumber_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, -0.7).isNaN()); -} - -TEST_F(LLVMLog10Test, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, inf).toDouble(), inf); -} - -TEST_F(LLVMLog10Test, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, inf).toDouble(), inf); -} - -TEST_F(LLVMLog10Test, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, -inf).isNaN()); -} - -TEST_F(LLVMLog10Test, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, -inf).isNaN()); -} - -TEST_F(LLVMLog10Test, NaN) -{ - static const double inf = std::numeric_limits::infinity(); - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, false, nan).toDouble(), -inf); -} - -TEST_F(LLVMLog10Test, NaN_Const) -{ - static const double inf = std::numeric_limits::infinity(); - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Log10, true, nan).toDouble(), -inf); -} diff --git a/test/llvm/operators/math/mod_test.cpp b/test/llvm/operators/math/mod_test.cpp deleted file mode 100644 index e8c9e38b4..000000000 --- a/test/llvm/operators/math/mod_test.cpp +++ /dev/null @@ -1,300 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMModTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMModTest, FourModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 4, 3); -} - -TEST_F(LLVMModTest, FourModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 4, 3); -} - -TEST_F(LLVMModTest, ThreeModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 3, 3); -} - -TEST_F(LLVMModTest, ThreeModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 3, 3); -} - -TEST_F(LLVMModTest, TwoModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 2, 3); -} - -TEST_F(LLVMModTest, TwoModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 2, 3); -} - -TEST_F(LLVMModTest, OneModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 1, 3); -} - -TEST_F(LLVMModTest, OneModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 1, 3); -} - -TEST_F(LLVMModTest, ZeroModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 0, 3); -} - -TEST_F(LLVMModTest, ZeroModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 0, 3); -} - -TEST_F(LLVMModTest, NegativeOneModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -1, 3); -} - -TEST_F(LLVMModTest, NegativeOneModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -1, 3); -} - -TEST_F(LLVMModTest, NegativeTwoModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -2, 3); -} - -TEST_F(LLVMModTest, NegativeTwoModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -2, 3); -} - -TEST_F(LLVMModTest, NegativeThreeModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -3, 3); -} - -TEST_F(LLVMModTest, NegativeThreeModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -3, 3); -} - -TEST_F(LLVMModTest, NegativeFourModThree) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -4, 3); -} - -TEST_F(LLVMModTest, NegativeFourModThree_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -4, 3); -} - -TEST_F(LLVMModTest, DecimalModTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 4.75, 2); -} - -TEST_F(LLVMModTest, DecimalModTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 4.75, 2); -} - -TEST_F(LLVMModTest, NegativeDecimalModTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -4.75, 2); -} - -TEST_F(LLVMModTest, NegativeDecimalModTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -4.75, 2); -} - -TEST_F(LLVMModTest, NegativeDecimalModNegativeTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -4.75, -2); -} - -TEST_F(LLVMModTest, NegativeDecimalModNegativeTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -4.75, -2); -} - -TEST_F(LLVMModTest, DecimalModNegativeTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 4.75, -2); -} - -TEST_F(LLVMModTest, DecimalModNegativeTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 4.75, -2); -} - -TEST_F(LLVMModTest, FiveModZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 5, 0); -} - -TEST_F(LLVMModTest, FiveModZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 5, 0); -} - -TEST_F(LLVMModTest, NegativeFiveModZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -5, 0); -} - -TEST_F(LLVMModTest, NegativeFiveModZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -5, 0); -} - -TEST_F(LLVMModTest, PositiveDecimalModZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 5.8, 0); -} - -TEST_F(LLVMModTest, PositiveDecimalModZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 5.8, 0); -} - -TEST_F(LLVMModTest, NegativeDecimalModZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -5.8, 0); -} - -TEST_F(LLVMModTest, NegativeDecimalModZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -5.8, 0); -} - -TEST_F(LLVMModTest, NegativeDecimalModInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -2.5, "Infinity"); -} - -TEST_F(LLVMModTest, NegativeDecimalModInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -2.5, "Infinity"); -} - -TEST_F(LLVMModTest, NegativeDecimalModNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -1.2, "-Infinity"); -} - -TEST_F(LLVMModTest, NegativeDecimalModNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -1.2, "-Infinity"); -} - -TEST_F(LLVMModTest, PositiveDecimalModInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 2.5, "Infinity"); -} - -TEST_F(LLVMModTest, PositiveDecimalModInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 2.5, "Infinity"); -} - -TEST_F(LLVMModTest, PositiveDecimalModNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 1.2, "-Infinity"); -} - -TEST_F(LLVMModTest, PositiveDecimalModNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 1.2, "-Infinity"); -} - -TEST_F(LLVMModTest, InfinityModTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "Infinity", 2); -} - -TEST_F(LLVMModTest, InfinityModTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "Infinity", 2); -} - -TEST_F(LLVMModTest, NegativeInfinityModTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "-Infinity", 2); -} - -TEST_F(LLVMModTest, NegativeInfinityModTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "-Infinity", 2); -} - -TEST_F(LLVMModTest, InfinityModNegativeTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "Infinity", -2); -} - -TEST_F(LLVMModTest, InfinityModNegativeTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "Infinity", -2); -} - -TEST_F(LLVMModTest, NegativeInfinityModNegativeTwo) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "-Infinity", -2); -} - -TEST_F(LLVMModTest, NegativeInfinityModNegativeTwo_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "-Infinity", -2); -} - -TEST_F(LLVMModTest, ThreeModNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, 3, "NaN"); -} - -TEST_F(LLVMModTest, ThreeModNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, 3, "NaN"); -} - -TEST_F(LLVMModTest, NegativeThreeModNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, -3, "NaN"); -} - -TEST_F(LLVMModTest, NegativeThreeModNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, -3, "NaN"); -} - -TEST_F(LLVMModTest, NaNModFive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "NaN", 5); -} - -TEST_F(LLVMModTest, NaNModFive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "NaN", 5); -} - -TEST_F(LLVMModTest, NaNModNegativeFive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, false, "NaN", -5); -} - -TEST_F(LLVMModTest, NaNModNegativeFive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mod, true, "NaN", -5); -} diff --git a/test/llvm/operators/math/multiply_test.cpp b/test/llvm/operators/math/multiply_test.cpp deleted file mode 100644 index acc368802..000000000 --- a/test/llvm/operators/math/multiply_test.cpp +++ /dev/null @@ -1,180 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMMultiplyTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMMultiplyTest, PositiveIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, 50, 2); -} - -TEST_F(LLVMMultiplyTest, PositiveIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, 50, 2); -} - -TEST_F(LLVMMultiplyTest, NegativeWithPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, -500, 25); -} - -TEST_F(LLVMMultiplyTest, NegativeWithPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, -500, 25); -} - -TEST_F(LLVMMultiplyTest, StringNegativeWithNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-500", -25); -} - -TEST_F(LLVMMultiplyTest, StringNegativeWithNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-500", -25); -} - -TEST_F(LLVMMultiplyTest, StringDecimals) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "2.54", "6.28"); -} - -TEST_F(LLVMMultiplyTest, StringDecimals_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "2.54", "6.28"); -} - -TEST_F(LLVMMultiplyTest, BooleanValues) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, true, true); -} - -TEST_F(LLVMMultiplyTest, BooleanValues_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, true, true); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "Infinity", 0); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "Infinity", 0); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "Infinity", 2); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "Infinity", 2); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "Infinity", -2); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "Infinity", -2); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMMultiplyTest, InfinityTimesNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesZero) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-Infinity", 0); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesZero_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-Infinity", 0); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-Infinity", 2); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-Infinity", 2); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesNegative) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-Infinity", -2); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesNegative_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-Infinity", -2); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMMultiplyTest, NegativeInfinityTimesNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMMultiplyTest, NumberTimesNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, 1, "NaN"); -} - -TEST_F(LLVMMultiplyTest, NumberTimesNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, 1, "NaN"); -} - -TEST_F(LLVMMultiplyTest, NaNTimesNumber) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, false, "NaN", 1); -} - -TEST_F(LLVMMultiplyTest, NaNTimesNumber_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Mul, true, "NaN", 1); -} diff --git a/test/llvm/operators/math/random_int_test.cpp b/test/llvm/operators/math/random_int_test.cpp deleted file mode 100644 index d224a4dac..000000000 --- a/test/llvm/operators/math/random_int_test.cpp +++ /dev/null @@ -1,134 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -using ::testing::Return; - -class LLVMRandomIntTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMRandomIntTest, IntegerRange) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-18)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, -45, 12); -} - -TEST_F(LLVMRandomIntTest, IntegerRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-18)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, -45, 12); -} - -TEST_F(LLVMRandomIntTest, DoubleAsInteger) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, -45.0, 12.0); -} - -TEST_F(LLVMRandomIntTest, DoubleAsInteger_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, -45.0, 12.0); -} - -TEST_F(LLVMRandomIntTest, TruncatedDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randint(12, 6)).Times(2).WillRepeatedly(Return(3)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, 12, 6.05); -} - -TEST_F(LLVMRandomIntTest, TruncatedDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(12, 6)).Times(2).WillRepeatedly(Return(3)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, 12, 6.05); -} - -TEST_F(LLVMRandomIntTest, NegativeDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randint(-78, -45)).Times(2).WillRepeatedly(Return(-59)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, -78.686, -45); -} - -TEST_F(LLVMRandomIntTest, NegativeDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-78, -45)).Times(2).WillRepeatedly(Return(-59)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, -78.686, -45); -} - -TEST_F(LLVMRandomIntTest, StringIntegerRange) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, "-45", "12"); -} - -TEST_F(LLVMRandomIntTest, StringIntegerRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, "-45", "12"); -} - -TEST_F(LLVMRandomIntTest, StringDoubleToInteger) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, "-45.0", "12"); -} - -TEST_F(LLVMRandomIntTest, StringDoubleToInteger_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, "-45.0", "12"); -} - -TEST_F(LLVMRandomIntTest, StringIntegerToDouble) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-15)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, "-45", "12.0"); -} - -TEST_F(LLVMRandomIntTest, StringIntegerToDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).Times(2).WillRepeatedly(Return(-15)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, "-45", "12.0"); -} - -TEST_F(LLVMRandomIntTest, BooleanRange) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 1)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, false, true); -} - -TEST_F(LLVMRandomIntTest, BooleanRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 1)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, false, true); -} - -TEST_F(LLVMRandomIntTest, BooleanWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint(1, 5)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, true, 5); -} - -TEST_F(LLVMRandomIntTest, BooleanWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(1, 5)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, true, 5); -} - -TEST_F(LLVMRandomIntTest, NumberWithBoolean) -{ - EXPECT_CALL(m_utils.rng(), randint(8, 0)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, false, 8, false); -} - -TEST_F(LLVMRandomIntTest, NumberWithBoolean_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(8, 0)).Times(2).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::RandomInt, true, 8, false); -} - -// NOTE: Infinity, -Infinity and NaN behavior is undefined diff --git a/test/llvm/operators/math/random_test.cpp b/test/llvm/operators/math/random_test.cpp deleted file mode 100644 index fb66a65f9..000000000 --- a/test/llvm/operators/math/random_test.cpp +++ /dev/null @@ -1,444 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -using ::testing::Return; - -class LLVMRandomTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMRandomTest, IntegerRange) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(-18)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -45, 12); -} - -TEST_F(LLVMRandomTest, IntegerRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(-18)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -45, 12); -} - -TEST_F(LLVMRandomTest, DoubleAsInteger) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -45.0, 12.0); -} - -TEST_F(LLVMRandomTest, DoubleAsInteger_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -45.0, 12.0); -} - -TEST_F(LLVMRandomTest, DoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(12, 6.05)).WillRepeatedly(Return(3.486789)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 12, 6.05); -} - -TEST_F(LLVMRandomTest, DoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(12, 6.05)).WillRepeatedly(Return(3.486789)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 12, 6.05); -} - -TEST_F(LLVMRandomTest, NegativeDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-78.686, -45)).WillRepeatedly(Return(-59.468873)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -78.686, -45); -} - -TEST_F(LLVMRandomTest, NegativeDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-78.686, -45)).WillRepeatedly(Return(-59.468873)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -78.686, -45); -} - -TEST_F(LLVMRandomTest, ReversedDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(-28.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 6.05, -78.686); -} - -TEST_F(LLVMRandomTest, ReversedDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(-28.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 6.05, -78.686); -} - -TEST_F(LLVMRandomTest, StringIntegerRange) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45", "12"); -} - -TEST_F(LLVMRandomTest, StringIntegerRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45", "12"); -} - -TEST_F(LLVMRandomTest, StringDoubleToInteger) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45.0", "12"); -} - -TEST_F(LLVMRandomTest, StringDoubleToInteger_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45.0", "12"); -} - -TEST_F(LLVMRandomTest, StringIntegerToDouble) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45", "12.0"); -} - -TEST_F(LLVMRandomTest, StringIntegerToDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45", "12.0"); -} - -TEST_F(LLVMRandomTest, StringDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(2.587964)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45.0", "12.0"); -} - -TEST_F(LLVMRandomTest, StringDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(2.587964)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45.0", "12.0"); -} - -TEST_F(LLVMRandomTest, StringReversedDoubleRange) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "6.05", "-78.686"); -} - -TEST_F(LLVMRandomTest, StringReversedDoubleRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "6.05", "-78.686"); -} - -TEST_F(LLVMRandomTest, MixedStringIntegerWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45", 12); -} - -TEST_F(LLVMRandomTest, MixedStringIntegerWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45", 12); -} - -TEST_F(LLVMRandomTest, MixedNumberWithStringInteger) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -45, "12"); -} - -TEST_F(LLVMRandomTest, MixedNumberWithStringInteger_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(-45, 12)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -45, "12"); -} - -TEST_F(LLVMRandomTest, MixedStringDoubleWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-45.0", 12); -} - -TEST_F(LLVMRandomTest, MixedStringDoubleWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(5.2)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-45.0", 12); -} - -TEST_F(LLVMRandomTest, MixedNumberWithStringDouble) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -45, "12.0"); -} - -TEST_F(LLVMRandomTest, MixedNumberWithStringDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(-45, 12)).WillRepeatedly(Return(-15.5787)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -45, "12.0"); -} - -TEST_F(LLVMRandomTest, MixedDoubleWithStringDouble) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 6.05, "-78.686"); -} - -TEST_F(LLVMRandomTest, MixedDoubleWithStringDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 6.05, "-78.686"); -} - -TEST_F(LLVMRandomTest, MixedStringDoubleWithDouble) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "6.05", -78.686); -} - -TEST_F(LLVMRandomTest, MixedStringDoubleWithDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randintDouble(6.05, -78.686)).WillRepeatedly(Return(5.648764)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "6.05", -78.686); -} - -TEST_F(LLVMRandomTest, BooleanRange) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 1)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, false, true); -} - -TEST_F(LLVMRandomTest, BooleanRange_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 1)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, false, true); -} - -TEST_F(LLVMRandomTest, BooleanWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint(1, 5)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, true, 5); -} - -TEST_F(LLVMRandomTest, BooleanWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(1, 5)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, true, 5); -} - -TEST_F(LLVMRandomTest, NumberWithBoolean) -{ - EXPECT_CALL(m_utils.rng(), randint(8, 0)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 8, false); -} - -TEST_F(LLVMRandomTest, NumberWithBoolean_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(8, 0)).WillRepeatedly(Return(1)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 8, false); -} - -TEST_F(LLVMRandomTest, NaNWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 5)).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "NaN", 5); -} - -TEST_F(LLVMRandomTest, NaNWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 5)).WillRepeatedly(Return(5)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "NaN", 5); -} - -TEST_F(LLVMRandomTest, NumberWithNaN) -{ - EXPECT_CALL(m_utils.rng(), randint(5, 0)).WillRepeatedly(Return(3)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 5, "NaN"); -} - -TEST_F(LLVMRandomTest, NumberWithNaN_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(5, 0)).WillRepeatedly(Return(3)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 5, "NaN"); -} - -TEST_F(LLVMRandomTest, NaNWithNaN) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 0)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "NaN", "NaN"); -} - -TEST_F(LLVMRandomTest, NaNWithNaN_Const) -{ - EXPECT_CALL(m_utils.rng(), randint(0, 0)).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "NaN", "NaN"); -} - -TEST_F(LLVMRandomTest, InfinityWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "Infinity", 2); -} - -TEST_F(LLVMRandomTest, InfinityWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "Infinity", 2); -} - -TEST_F(LLVMRandomTest, NumberWithInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -8, "Infinity"); -} - -TEST_F(LLVMRandomTest, NumberWithInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -8, "Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithNumber) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-Infinity", -2); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithNumber_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-Infinity", -2); -} - -TEST_F(LLVMRandomTest, NumberWithNegativeInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 8, "-Infinity"); -} - -TEST_F(LLVMRandomTest, NumberWithNegativeInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 8, "-Infinity"); -} - -TEST_F(LLVMRandomTest, InfinityWithDouble) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "Infinity", 2.5); -} - -TEST_F(LLVMRandomTest, InfinityWithDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "Infinity", 2.5); -} - -TEST_F(LLVMRandomTest, DoubleWithInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, -8.09, "Infinity"); -} - -TEST_F(LLVMRandomTest, DoubleWithInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, -8.09, "Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithDouble) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-Infinity", -2.5); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithDouble_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-Infinity", -2.5); -} - -TEST_F(LLVMRandomTest, DoubleWithNegativeInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, 8.09, "-Infinity"); -} - -TEST_F(LLVMRandomTest, DoubleWithNegativeInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, 8.09, "-Infinity"); -} - -TEST_F(LLVMRandomTest, InfinityWithInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMRandomTest, InfinityWithInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithNegativeInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithNegativeInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMRandomTest, InfinityWithNegativeInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMRandomTest, InfinityWithNegativeInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithInfinity) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMRandomTest, NegativeInfinityWithInfinity_Const) -{ - EXPECT_CALL(m_utils.rng(), randint).WillRepeatedly(Return(0)); - EXPECT_CALL(m_utils.rng(), randintDouble).WillRepeatedly(Return(0)); - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Random, true, "-Infinity", "Infinity"); -} diff --git a/test/llvm/operators/math/round_test.cpp b/test/llvm/operators/math/round_test.cpp deleted file mode 100644 index f1e3d4cd4..000000000 --- a/test/llvm/operators/math/round_test.cpp +++ /dev/null @@ -1,156 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMRoundTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMRoundTest, FourPointZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, FourPointZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, 4.0).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, NegativeFourPointZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -4.0).toDouble(), -4.0); -} - -TEST_F(LLVMRoundTest, NegativeFourPointZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -4.0).toDouble(), -4.0); -} - -TEST_F(LLVMRoundTest, ThreePointTwo) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, 3.2).toDouble(), 3.0); -} - -TEST_F(LLVMRoundTest, ThreePointTwo_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, 3.2).toDouble(), 3.0); -} - -TEST_F(LLVMRoundTest, ThreePointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, 3.5).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, ThreePointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, 3.5).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, ThreePointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, 3.6).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, ThreePointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, 3.6).toDouble(), 4.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -2.4).toDouble(), -2.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -2.4).toDouble(), -2.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -2.5).toDouble(), -2.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -2.5).toDouble(), -2.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointSix) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -2.6).toDouble(), -3.0); -} - -TEST_F(LLVMRoundTest, NegativeTwoPointSix_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -2.6).toDouble(), -3.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -0.4).toDouble(), -0.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -0.4).toDouble(), -0.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFive) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -0.5).toDouble(), -0.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFive_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -0.5).toDouble(), -0.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFiftyOne) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -0.51).toDouble(), -1.0); -} - -TEST_F(LLVMRoundTest, NegativeZeroPointFiftyOne_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -0.51).toDouble(), -1.0); -} - -TEST_F(LLVMRoundTest, Infinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, inf).toDouble(), inf); -} - -TEST_F(LLVMRoundTest, Infinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, inf).toDouble(), inf); -} - -TEST_F(LLVMRoundTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, -inf).toDouble(), -inf); -} - -TEST_F(LLVMRoundTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, -inf).toDouble(), -inf); -} - -TEST_F(LLVMRoundTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, false, nan).toDouble(), 0); -} - -TEST_F(LLVMRoundTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Round, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/sin_test.cpp b/test/llvm/operators/math/sin_test.cpp deleted file mode 100644 index caaa0ea0a..000000000 --- a/test/llvm/operators/math/sin_test.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMSinTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMSinTest, ThirtyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 30.0).toDouble(), 0.5); -} - -TEST_F(LLVMSinTest, ThirtyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 30.0).toDouble(), 0.5); -} - -TEST_F(LLVMSinTest, NinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 90.0).toDouble(), 1.0); -} - -TEST_F(LLVMSinTest, NinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 90.0).toDouble(), 1.0); -} - -TEST_F(LLVMSinTest, VerySmallAngle) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 2.8e-9).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, VerySmallAngle_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 2.8e-9).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, SlightlyLargerSmallAngle) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 2.9e-9).toDouble(), 1e-10); -} - -TEST_F(LLVMSinTest, SlightlyLargerSmallAngle_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 2.9e-9).toDouble(), 1e-10); -} - -TEST_F(LLVMSinTest, FiveSeventyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 570.0).toDouble(), -0.5); -} - -TEST_F(LLVMSinTest, FiveSeventyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 570.0).toDouble(), -0.5); -} - -TEST_F(LLVMSinTest, NegativeThirtyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, -30.0).toDouble(), -0.5); -} - -TEST_F(LLVMSinTest, NegativeThirtyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, -30.0).toDouble(), -0.5); -} - -TEST_F(LLVMSinTest, NegativeNinetyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, -90.0).toDouble(), -1.0); -} - -TEST_F(LLVMSinTest, NegativeNinetyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, -90.0).toDouble(), -1.0); -} - -TEST_F(LLVMSinTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSinTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, inf).isNaN()); -} - -TEST_F(LLVMSinTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, inf).isNaN()); -} - -TEST_F(LLVMSinTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, -inf).isNaN()); -} - -TEST_F(LLVMSinTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, -inf).isNaN()); -} - -TEST_F(LLVMSinTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, false, nan).toDouble(), 0); -} - -TEST_F(LLVMSinTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sin, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/sqrt_test.cpp b/test/llvm/operators/math/sqrt_test.cpp deleted file mode 100644 index faab7f42d..000000000 --- a/test/llvm/operators/math/sqrt_test.cpp +++ /dev/null @@ -1,96 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMSqrtTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMSqrtTest, SixteenPointZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, 16.0).toDouble(), 4.0); -} - -TEST_F(LLVMSqrtTest, SixteenPointZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, 16.0).toDouble(), 4.0); -} - -TEST_F(LLVMSqrtTest, ZeroPointZeroFour) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, 0.04).toDouble(), 0.2); -} - -TEST_F(LLVMSqrtTest, ZeroPointZeroFour_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, 0.04).toDouble(), 0.2); -} - -TEST_F(LLVMSqrtTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSqrtTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSqrtTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSqrtTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMSqrtTest, NegativeFour) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, -4.0).isNaN()); -} - -TEST_F(LLVMSqrtTest, NegativeFour_Const) -{ - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, -4.0).isNaN()); -} - -TEST_F(LLVMSqrtTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, inf).toDouble(), inf); -} - -TEST_F(LLVMSqrtTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, inf).toDouble(), inf); -} - -TEST_F(LLVMSqrtTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, -inf).isNaN()); -} - -TEST_F(LLVMSqrtTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, -inf).isNaN()); -} - -TEST_F(LLVMSqrtTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, false, nan).toDouble(), 0); -} - -TEST_F(LLVMSqrtTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Sqrt, true, nan).toDouble(), 0); -} diff --git a/test/llvm/operators/math/subtract_test.cpp b/test/llvm/operators/math/subtract_test.cpp deleted file mode 100644 index aa24dd022..000000000 --- a/test/llvm/operators/math/subtract_test.cpp +++ /dev/null @@ -1,130 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMSubtractTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMSubtractTest, PositiveIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, 50, 25); -} - -TEST_F(LLVMSubtractTest, PositiveIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, 50, 25); -} - -TEST_F(LLVMSubtractTest, NegativeWithPositive) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, -500, 25); -} - -TEST_F(LLVMSubtractTest, NegativeWithPositive_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, -500, 25); -} - -TEST_F(LLVMSubtractTest, NegativeIntegers) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, -500, -25); -} - -TEST_F(LLVMSubtractTest, NegativeIntegers_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, -500, -25); -} - -TEST_F(LLVMSubtractTest, StringDecimals) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "2.54", "6.28"); -} - -TEST_F(LLVMSubtractTest, StringDecimals_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "2.54", "6.28"); -} - -TEST_F(LLVMSubtractTest, MixedDecimalAndString) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, 2.54, "-6.28"); -} - -TEST_F(LLVMSubtractTest, MixedDecimalAndString_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, 2.54, "-6.28"); -} - -TEST_F(LLVMSubtractTest, BooleanValues) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, true, true); -} - -TEST_F(LLVMSubtractTest, BooleanValues_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, true, true); -} - -TEST_F(LLVMSubtractTest, InfinityMinusInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMSubtractTest, InfinityMinusInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMSubtractTest, InfinityMinusNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMSubtractTest, InfinityMinusNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMSubtractTest, NegativeInfinityMinusInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMSubtractTest, NegativeInfinityMinusInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMSubtractTest, NegativeInfinityMinusNegativeInfinity) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMSubtractTest, NegativeInfinityMinusNegativeInfinity_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMSubtractTest, NumberMinusNaN) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, 1, "NaN"); -} - -TEST_F(LLVMSubtractTest, NumberMinusNaN_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, 1, "NaN"); -} - -TEST_F(LLVMSubtractTest, NaNMinusNumber) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, false, "NaN", 1); -} - -TEST_F(LLVMSubtractTest, NaNMinusNumber_Const) -{ - ASSERT_NUM_OP2(m_utils, LLVMTestUtils::OpType::Sub, true, "NaN", 1); -} diff --git a/test/llvm/operators/math/tan_test.cpp b/test/llvm/operators/math/tan_test.cpp deleted file mode 100644 index c0f7f59f5..000000000 --- a/test/llvm/operators/math/tan_test.cpp +++ /dev/null @@ -1,188 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMTanTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMTanTest, FortyFiveDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 45.0).toDouble(), 1.0); -} - -TEST_F(LLVMTanTest, FortyFiveDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 45.0).toDouble(), 1.0); -} - -TEST_F(LLVMTanTest, NinetyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 90.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, NinetyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 90.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, TwoSeventyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 270.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, TwoSeventyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 270.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, FourFiftyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 450.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, FourFiftyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 450.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, NegativeNinetyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -90.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, NegativeNinetyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -90.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, NegativeTwoSeventyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -270.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, NegativeTwoSeventyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -270.0).toDouble(), inf); -} - -TEST_F(LLVMTanTest, NegativeFourFiftyDegrees) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -450.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, NegativeFourFiftyDegrees_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -450.0).toDouble(), -inf); -} - -TEST_F(LLVMTanTest, OneEightyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 180.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, OneEightyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 180.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, NegativeOneEightyDegrees) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -180.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, NegativeOneEightyDegrees_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -180.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, VerySmallAngle) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 2.87e-9).toDouble(), 1e-10); -} - -TEST_F(LLVMTanTest, VerySmallAngle_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 2.87e-9).toDouble(), 1e-10); -} - -TEST_F(LLVMTanTest, EvenSmallerAngle) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 2.8647e-9).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, EvenSmallerAngle_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 2.8647e-9).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, PositiveZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, PositiveZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, 0.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, NegativeZero) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, NegativeZero_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -0.0).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, PositiveInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, inf).isNaN()); -} - -TEST_F(LLVMTanTest, PositiveInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, inf).isNaN()); -} - -TEST_F(LLVMTanTest, NegativeInfinity) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, -inf).isNaN()); -} - -TEST_F(LLVMTanTest, NegativeInfinity_Const) -{ - static const double inf = std::numeric_limits::infinity(); - ASSERT_TRUE(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, -inf).isNaN()); -} - -TEST_F(LLVMTanTest, NaN) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, false, nan).toDouble(), 0.0); -} - -TEST_F(LLVMTanTest, NaN_Const) -{ - static const double nan = std::numeric_limits::quiet_NaN(); - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::Tan, true, nan).toDouble(), 0.0); -} diff --git a/test/llvm/operators/string/string_char_test.cpp b/test/llvm/operators/string/string_char_test.cpp deleted file mode 100644 index c8755a67c..000000000 --- a/test/llvm/operators/string/string_char_test.cpp +++ /dev/null @@ -1,80 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMStringCharTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMStringCharTest, HelloWorldSecondChar) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "Hello world", 1).toString(), "e"); -} - -TEST_F(LLVMStringCharTest, HelloWorldSecondChar_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "Hello world", 1).toString(), "e"); -} - -TEST_F(LLVMStringCharTest, HelloWorldZeroIndex) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "Hello world", 0).toString(), "H"); -} - -TEST_F(LLVMStringCharTest, HelloWorldZeroIndex_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "Hello world", 0).toString(), "H"); -} - -TEST_F(LLVMStringCharTest, HelloWorldOutOfRange) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "Hello world", 11).toString(), ""); -} - -TEST_F(LLVMStringCharTest, HelloWorldOutOfRange_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "Hello world", 11).toString(), ""); -} - -TEST_F(LLVMStringCharTest, AbcThirdChar) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "abc", 2).toString(), "c"); -} - -TEST_F(LLVMStringCharTest, AbcThirdChar_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "abc", 2).toString(), "c"); -} - -TEST_F(LLVMStringCharTest, AbcNegativeIndex) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "abc", -1).toString(), ""); -} - -TEST_F(LLVMStringCharTest, AbcNegativeIndex_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "abc", -1).toString(), ""); -} - -TEST_F(LLVMStringCharTest, AbcOutOfRange) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "abc", 3).toString(), ""); -} - -TEST_F(LLVMStringCharTest, AbcOutOfRange_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "abc", 3).toString(), ""); -} - -TEST_F(LLVMStringCharTest, UnicodeString) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, false, "ábč", 0).toString(), "á"); -} - -TEST_F(LLVMStringCharTest, UnicodeString_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringChar, true, "ábč", 0).toString(), "á"); -} diff --git a/test/llvm/operators/string/string_concat_test.cpp b/test/llvm/operators/string/string_concat_test.cpp deleted file mode 100644 index 9492b1919..000000000 --- a/test/llvm/operators/string/string_concat_test.cpp +++ /dev/null @@ -1,40 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMStringConcatTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMStringConcatTest, HelloWorld) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, false, "Hello ", "world").toString(), "Hello world"); -} - -TEST_F(LLVMStringConcatTest, HelloWorld_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, true, "Hello ", "world").toString(), "Hello world"); -} - -TEST_F(LLVMStringConcatTest, AbcDef) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, false, "abc", "def").toString(), "abcdef"); -} - -TEST_F(LLVMStringConcatTest, AbcDef_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, true, "abc", "def").toString(), "abcdef"); -} - -TEST_F(LLVMStringConcatTest, UnicodeStrings) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, false, "ábč", "ďéfgh").toString(), "ábčďéfgh"); -} - -TEST_F(LLVMStringConcatTest, UnicodeStrings_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringConcat, true, "ábč", "ďéfgh").toString(), "ábčďéfgh"); -} diff --git a/test/llvm/operators/string/string_equal_case_insensitive_test.cpp b/test/llvm/operators/string/string_equal_case_insensitive_test.cpp deleted file mode 100644 index 3ef1b33a7..000000000 --- a/test/llvm/operators/string/string_equal_case_insensitive_test.cpp +++ /dev/null @@ -1,1210 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMStringEqualCaseInsensitiveTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 10, 10); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 10, 10); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 10, 8); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 10, 8); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentIntegersReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 8, 10); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentIntegersReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 8, 10); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, -4.25, -4.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, -4.25, -4.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, -4.25, 5.312); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, -4.25, 5.312); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentDecimalsReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.312, -4.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentDecimalsReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.312, -4.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentBooleansReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentBooleansReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 1, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 1, true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 1, false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 1, false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "abC def", "abC def"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SameStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "abC def", "abC def"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringsCaseDifferent) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "abC def", "abc dEf"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringsCaseDifferent_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "abC def", "abc dEf"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringsLonger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "abC def", "hello world"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringsLonger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "abC def", "hello world"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, " ", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, " ", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, " ", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, " ", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, " ", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, SpaceVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, " ", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, EmptyVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, EmptyVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, EmptyVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, EmptyVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroStringVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "0", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroStringVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "0", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroNumberVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.25"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.25"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ExactStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ExactStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithLeadingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.25, " 5.25"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithLeadingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.25, " 5.25"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithLeadingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, " 5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithLeadingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, " 5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.25 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.25 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithTrailingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithTrailingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithSurroundingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.25, " 5.25 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithSurroundingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.25, " 5.25 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithSurroundingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, " 5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithSurroundingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, " 5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsDifferentString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5.25, "5.26"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsDifferentString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5.25, "5.26"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "5.26", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "5.26", 5.25); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringNumbers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "5.25", "5.26"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, DifferentStringNumbers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "5.25", "5.26"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5, "5 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberVsStringWithTrailingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5, "5 "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithTrailingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "5 ", 5); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, StringWithTrailingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "5 ", 5); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroVsOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "1"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroVsOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "1"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "1", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "1", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroVsTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "test"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroVsTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "test"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TestStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "test", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TestStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "test", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 5, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NumberWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 5, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "TRUE", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "TRUE", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "FALSE", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "FALSE", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "00001"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "00001"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "00001", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "00001", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "00000"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "00000"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "00000", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "00000", true); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "00000"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "00000"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "00000", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "00000", false); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", 1); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", 1); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 1, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 1, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "true"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", 0); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 0, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 0, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", 1); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", 1); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, 1, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, 1, "false"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "true", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "true", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "false", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "false", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, true, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, true, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, false, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, false, "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "nan", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "nan", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "nan", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "nan", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "nan", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "nan", "NaN"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, InfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "-Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NegativeInfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "-Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "abc"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", " "); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", ""); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, false, "NaN", "0"); -} - -TEST_F(LLVMStringEqualCaseInsensitiveTest, NaNWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCI, true, "NaN", "0"); -} diff --git a/test/llvm/operators/string/string_equal_case_sensitive_test.cpp b/test/llvm/operators/string/string_equal_case_sensitive_test.cpp deleted file mode 100644 index fc8ae7db4..000000000 --- a/test/llvm/operators/string/string_equal_case_sensitive_test.cpp +++ /dev/null @@ -1,1210 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMStringEqualCaseSensitiveTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 10, 10); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 10, 10); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentIntegers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 10, 8); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentIntegers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 10, 8); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentIntegersReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 8, 10); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentIntegersReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 8, 10); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, -4.25, -4.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, -4.25, -4.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentDecimals) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, -4.25, 5.312); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentDecimals_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, -4.25, 5.312); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentDecimalsReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.312, -4.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentDecimalsReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.312, -4.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentBooleans) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentBooleans_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentBooleansReversed) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentBooleansReversed_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 1, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 1, true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 1, false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 1, false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "abC def", "abC def"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SameStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "abC def", "abC def"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringsCaseDifferent) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "abC def", "abc dEf"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringsCaseDifferent_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "abC def", "abc dEf"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStrings) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStrings_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "abC def", "ghi Jkl"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringsLonger) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "abC def", "hello world"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringsLonger_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "abC def", "hello world"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, " ", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, " ", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, " ", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, " ", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, " ", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, SpaceVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, " ", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, EmptyVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, EmptyVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, EmptyVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, EmptyVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsEmpty) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsEmpty_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroStringVsZeroNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "0", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroStringVsZeroNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "0", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroNumberVsZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsExactString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.25"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsExactString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.25"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ExactStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ExactStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithLeadingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.25, " 5.25"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithLeadingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.25, " 5.25"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithLeadingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, " 5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithLeadingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, " 5.25", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.25 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.25 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithTrailingSpaceVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithTrailingSpaceVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithSurroundingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.25, " 5.25 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithSurroundingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.25, " 5.25 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithSurroundingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, " 5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithSurroundingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, " 5.25 ", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsDifferentString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5.25, "5.26"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsDifferentString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5.25, "5.26"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "5.26", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "5.26", 5.25); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringNumbers) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "5.25", "5.26"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, DifferentStringNumbers_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "5.25", "5.26"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpaces) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5, "5 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberVsStringWithTrailingSpaces_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5, "5 "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithTrailingSpacesVsNumber) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "5 ", 5); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, StringWithTrailingSpacesVsNumber_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "5 ", 5); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroVsOneString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "1"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroVsOneString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "1"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "1", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "1", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroVsTestString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "test"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroVsTestString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "test"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TestStringVsZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "test", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TestStringVsZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "test", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 5, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NumberWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 5, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, UppercaseTrueStringWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "TRUE", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, UppercaseTrueStringWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "TRUE", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, UppercaseFalseStringWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "FALSE", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, UppercaseFalseStringWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "FALSE", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "00001"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "00001"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedOneWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "00001", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedOneWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "00001", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "00000"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "00000"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedZeroWithTrueBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "00000", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedZeroWithTrueBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "00000", true); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithZeroPaddedZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "00000"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithZeroPaddedZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "00000"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedZeroWithFalseBoolean) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "00000", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroPaddedZeroWithFalseBoolean_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "00000", false); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", 1); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", 1); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 1, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 1, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "true"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithZero) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithZero_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", 0); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 0, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, ZeroWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 0, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithOne) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", 1); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithOne_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", 1); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneWithFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, 1, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, OneWithFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, 1, "false"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "true", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "true", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithUppercaseFalseString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithUppercaseFalseString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", "FALSE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithUppercaseTrueString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "false", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseStringWithUppercaseTrueString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "false", "TRUE"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, true, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, TrueBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, true, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, false, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, FalseBooleanWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, false, "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-infinity", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-infinity", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNegativeInfinityStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-infinity", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "nan", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "nan", "Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithNegativeInfinity) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "nan", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithNegativeInfinity_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "nan", "-Infinity"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithNaN) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "nan", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, LowercaseNaNStringWithNaN_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "nan", "NaN"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, InfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "-Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NegativeInfinityWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "-Infinity", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithStringAbc) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithStringAbc_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "abc"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithStringSpace) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithStringSpace_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", " "); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithEmptyString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithEmptyString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", ""); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithZeroString) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, false, "NaN", "0"); -} - -TEST_F(LLVMStringEqualCaseSensitiveTest, NaNWithZeroString_Const) -{ - ASSERT_BOOL_OP2(m_utils, LLVMTestUtils::OpType::StrCmpEQCS, true, "NaN", "0"); -} diff --git a/test/llvm/operators/string/string_length_test.cpp b/test/llvm/operators/string/string_length_test.cpp deleted file mode 100644 index f0ce51d53..000000000 --- a/test/llvm/operators/string/string_length_test.cpp +++ /dev/null @@ -1,50 +0,0 @@ -#include -#include - -#include "llvmtestutils.h" - -class LLVMStringLengthTest : public testing::Test -{ - public: - LLVMTestUtils m_utils; -}; - -TEST_F(LLVMStringLengthTest, HelloWorld) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, false, "Hello world").toDouble(), 11); -} - -TEST_F(LLVMStringLengthTest, HelloWorld_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, true, "Hello world").toDouble(), 11); -} - -TEST_F(LLVMStringLengthTest, Abc) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, false, "abc").toDouble(), 3); -} - -TEST_F(LLVMStringLengthTest, Abc_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, true, "abc").toDouble(), 3); -} - -TEST_F(LLVMStringLengthTest, Abcdef) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, false, "abcdef").toDouble(), 6); -} - -TEST_F(LLVMStringLengthTest, Abcdef_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, true, "abcdef").toDouble(), 6); -} - -TEST_F(LLVMStringLengthTest, UnicodeString) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, false, "ábč").toDouble(), 3); -} - -TEST_F(LLVMStringLengthTest, UnicodeString_Const) -{ - ASSERT_EQ(m_utils.getOpResult(LLVMTestUtils::OpType::StringLength, true, "ábč").toDouble(), 3); -}