2020-10-08 00:06:48 -04:00
|
|
|
#include <thread>
|
|
|
|
#include <chrono>
|
|
|
|
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "game/runtime.h"
|
|
|
|
#include "goalc/listener/Listener.h"
|
|
|
|
#include "goalc/compiler/Compiler.h"
|
|
|
|
|
2020-10-09 21:28:41 -04:00
|
|
|
#include "inja.hpp"
|
2020-10-08 00:06:48 -04:00
|
|
|
#include "third-party/json.hpp"
|
2020-10-09 19:52:09 -04:00
|
|
|
#include "common/util/FileUtil.h"
|
|
|
|
#include <test/goalc/framework/test_runner.h>
|
2020-10-29 21:27:52 -04:00
|
|
|
#include "third-party/fmt/core.h"
|
2020-10-08 00:06:48 -04:00
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
#include <string>
|
|
|
|
#include <cstdio>
|
|
|
|
#include <sstream>
|
|
|
|
#include <iostream>
|
|
|
|
#include <random>
|
|
|
|
#include <filesystem>
|
|
|
|
|
|
|
|
struct WithGameParam {
|
|
|
|
// TODO - Not Needed Yet
|
|
|
|
};
|
|
|
|
|
|
|
|
class WithGameTests : public testing::TestWithParam<WithGameParam> {
|
|
|
|
public:
|
|
|
|
static void SetUpTestSuite() {
|
2020-10-09 19:37:09 -04:00
|
|
|
try {
|
2020-11-19 21:22:16 -05:00
|
|
|
compiler.run_test_no_load("test/goalc/source_templates/with_game/test-build-game.gc");
|
2020-10-09 19:37:09 -04:00
|
|
|
} catch (std::exception& e) {
|
|
|
|
fprintf(stderr, "caught exception %s\n", e.what());
|
|
|
|
EXPECT_TRUE(false);
|
|
|
|
}
|
2020-11-19 21:22:16 -05:00
|
|
|
runtime_thread = std::thread((GoalTest::runtime_with_kernel));
|
|
|
|
runner.c = &compiler;
|
|
|
|
|
|
|
|
compiler.run_test_from_file("test/goalc/source_templates/with_game/test-load-game.gc");
|
2020-10-08 00:06:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void TearDownTestSuite() {
|
|
|
|
compiler.shutdown_target();
|
|
|
|
runtime_thread.join();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetUp() {
|
|
|
|
GoalTest::createDirIfAbsent(GoalTest::getTemplateDir(testCategory));
|
|
|
|
GoalTest::createDirIfAbsent(GoalTest::getGeneratedDir(testCategory));
|
|
|
|
}
|
|
|
|
|
|
|
|
void TearDown() {}
|
|
|
|
|
|
|
|
static std::thread runtime_thread;
|
|
|
|
static Compiler compiler;
|
|
|
|
static GoalTest::CompilerTestRunner runner;
|
|
|
|
|
|
|
|
std::string testCategory = "with_game";
|
|
|
|
inja::Environment env{GoalTest::getTemplateDir(testCategory),
|
|
|
|
GoalTest::getGeneratedDir(testCategory)};
|
|
|
|
};
|
|
|
|
|
|
|
|
std::thread WithGameTests::runtime_thread;
|
|
|
|
Compiler WithGameTests::compiler;
|
|
|
|
GoalTest::CompilerTestRunner WithGameTests::runner;
|
|
|
|
|
2020-10-14 13:42:14 -04:00
|
|
|
namespace {
|
|
|
|
std::vector<std::string> get_test_pass_string(const std::string& name, int count) {
|
|
|
|
return {fmt::format("Test \"{}\": {} Passes\n0\n", name, count)};
|
|
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
2020-11-19 21:22:16 -05:00
|
|
|
TEST_F(WithGameTests, ReturnConstant) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "defun-return-constant.static.gc", {"12\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, ReturnSymbol) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "defun-return-symbol.static.gc", {"42\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, MinMax) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-min-max.gc", {"10\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, BoxedFloat) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-bfloat.gc",
|
|
|
|
{"data 1.2330 print 1.2330 type bfloat\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, BasicTypeCheck) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-basic-type-check.gc", {"#f#t#t#f#t#f#t#t\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, ConditionBoolean) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-condition-boolean.gc", {"4\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, TypeType) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-type-type.gc", {"#t#f\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, AccessInlineArray) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-access-inline-array.gc", {"1.2345\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, FindParentMethod) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-find-parent-method.gc", {"\"test pass!\"\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Ref) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-ref.gc", {"83\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, PairASzie) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-pair-asize.gc", {"8\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Last) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-last.gc", {"d\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Sort) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(
|
|
|
|
env, testCategory, "test-sort.gc",
|
|
|
|
{"(24 16 32 56 72 1234 -34 25 654)\n(1234 654 72 56 32 25 24 16 -34)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Sort2) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(
|
|
|
|
env, testCategory, "test-sort-2.gc",
|
|
|
|
{"(24 16 32 56 72 1234 -34 25 654)\n(-34 16 24 25 32 56 72 654 1234)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Sort3) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(
|
|
|
|
env, testCategory, "test-sort-3.gc",
|
|
|
|
{"(24 16 32 56 72 1234 -34 25 654)\n(-34 16 24 25 32 56 72 654 1234)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, PairLength) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-pair-length.gc", {"6\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Member1) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-member-1.gc", {"(c d)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Member2) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-member-2.gc", {"#f\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Assoc1) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-assoc-1.gc", {"w\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Assoc2) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-assoc-2.gc", {"#f\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Assoce1) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-assoce-1.gc", {"x\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Assoce2) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-assoce-2.gc", {"x\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Append) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-append.gc", {"(a b c d e)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, DeleteList) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-delete-list.gc", {"(a b d e)\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, DeleteCar) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-delete-car.gc", {"((a . b) (e . f))\n#f\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, InsertCar) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-insert-cons.gc",
|
|
|
|
{"((c . w) (a . b) (e . f))\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, InlineArrayClass) {
|
2020-10-24 22:51:40 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-new-inline-array-class.gc", {"2824\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Memcpy) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-memcpy.gc", {"13\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, Memset) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-memset.gc", {"11\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, BintegerPrint) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-binteger-print.gc", {"-17\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, TestTests) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-tests.gc",
|
|
|
|
{"Test Failed On Test 0: \"unknown\"\nTest Failed On Test 0: "
|
|
|
|
"\"test\"\nTest \"test-of-test\": 1 Passes\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, TypeArrays) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-type-arrays.gc",
|
|
|
|
{"Test \"test-type-arrays\": 3 Passes\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, NumberComparison) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-number-comparison.gc",
|
|
|
|
{"Test \"number-comparison\": 14 Passes\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, ApproxPi) {
|
2020-10-14 13:42:14 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-approx-pi.gc",
|
2020-10-08 00:06:48 -04:00
|
|
|
get_test_pass_string("approx-pi", 4));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
2020-11-22 12:22:19 -05:00
|
|
|
TEST_F(WithGameTests, ApproxPiStack) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-approx-pi-stack.gc",
|
|
|
|
get_test_pass_string("approx-pi-stack", 4));
|
|
|
|
}
|
|
|
|
|
2020-11-19 21:22:16 -05:00
|
|
|
TEST_F(WithGameTests, DynamicType) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-dynamic-type.gc",
|
|
|
|
get_test_pass_string("dynamic-type", 4));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, StringType) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-string-type.gc",
|
|
|
|
get_test_pass_string("string-type", 4));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, NewString) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-new-string.gc",
|
2020-10-14 13:42:14 -04:00
|
|
|
get_test_pass_string("new-string", 5));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, AddrOf) {
|
2020-10-14 13:42:14 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-addr-of.gc", get_test_pass_string("addr-of", 2));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, SetSelf) {
|
2020-10-08 00:06:48 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-set-self.gc", {"#t\n0\n"});
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, NewArray) {
|
2020-10-14 13:42:14 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-new-array.gc",
|
|
|
|
get_test_pass_string("new-array", 8));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, NewStaticStructureIntegers) {
|
2020-10-16 17:08:26 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-new-static-structure-integers.gc",
|
|
|
|
get_test_pass_string("new-static-structure-integers", 7));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, NewStaticBasic) {
|
2020-10-16 17:08:26 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-new-static-basic.gc",
|
|
|
|
get_test_pass_string("new-static-basic", 9));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, VectorDot) {
|
2020-10-25 20:30:25 -04:00
|
|
|
runner.run_static_test(env, testCategory, "test-vector-dot.gc",
|
|
|
|
get_test_pass_string("vector-dot", 1));
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
2020-11-13 22:33:57 -05:00
|
|
|
|
2020-11-19 21:22:16 -05:00
|
|
|
TEST_F(WithGameTests, DebuggerMemoryMap) {
|
2020-11-13 22:33:57 -05:00
|
|
|
auto mem_map = compiler.listener().build_memory_map();
|
|
|
|
|
|
|
|
// we should have gkernel main segment
|
|
|
|
listener::MemoryMapEntry gk_main;
|
|
|
|
EXPECT_TRUE(mem_map.lookup("gkernel", MAIN_SEGMENT, &gk_main));
|
|
|
|
auto lookup_2 = mem_map.lookup(gk_main.start_addr + 12);
|
|
|
|
EXPECT_TRUE(lookup_2.obj_name == "gkernel");
|
|
|
|
EXPECT_FALSE(lookup_2.empty);
|
|
|
|
EXPECT_EQ(lookup_2.seg_id, MAIN_SEGMENT);
|
2020-11-19 21:22:16 -05:00
|
|
|
}
|
2020-11-13 22:33:57 -05:00
|
|
|
|
2020-11-19 21:22:16 -05:00
|
|
|
TEST_F(WithGameTests, DebuggerDisassemble) {
|
2020-11-13 22:33:57 -05:00
|
|
|
auto di = compiler.get_debugger().get_debug_info_for_object("gcommon");
|
|
|
|
bool fail = false;
|
|
|
|
auto result = di.disassemble_debug_functions(&fail);
|
|
|
|
// printf("Got\n%s\n", result.c_str());
|
|
|
|
EXPECT_FALSE(fail);
|
2020-10-08 00:06:48 -04:00
|
|
|
}
|
2020-10-24 22:51:40 -04:00
|
|
|
|
2020-11-19 21:22:16 -05:00
|
|
|
TEST_F(WithGameTests, GameText) {
|
|
|
|
compiler.run_test_from_string("(asm-data-file game-text \"test/test_data/test_game_text.txt\")");
|
|
|
|
runner.run_static_test(env, testCategory, "test-game-text.gc",
|
|
|
|
get_test_pass_string("game-text", 5));
|
|
|
|
}
|
|
|
|
|
2020-11-24 20:48:38 -05:00
|
|
|
TEST_F(WithGameTests, GameCount) {
|
|
|
|
compiler.run_test_from_string(
|
|
|
|
"(asm-data-file game-count \"test/test_data/test_game_counts.txt\")");
|
|
|
|
compiler.run_test_from_string("(build-dgos \"test/test_data/test_game_count_dgos.txt\")");
|
|
|
|
compiler.run_test_from_string("(dgo-load \"game\" global #xf #x200000)");
|
|
|
|
runner.run_static_test(env, testCategory, "test-game-count.gc",
|
|
|
|
get_test_pass_string("game-count", 4));
|
|
|
|
}
|
|
|
|
|
2020-11-29 18:01:30 -05:00
|
|
|
TEST_F(WithGameTests, BitFieldAccess) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-bitfield-access.gc",
|
|
|
|
{"#tfffffffffffff344f213ffffffffffffffff\n0\n"});
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, SimpleBitField) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-set-bitfield.gc", {"#t50.3432\n0\n"});
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, StaticBitField) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-static-bitfield.gc", {"#t50.3432\n0\n"});
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(WithGameTests, TrickyBitField) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-bitfield-tricky-access.gc",
|
|
|
|
get_test_pass_string("bitfield-tricky-access", 14));
|
|
|
|
}
|
|
|
|
|
2020-11-28 19:59:23 -05:00
|
|
|
TEST_F(WithGameTests, Math) {
|
|
|
|
runner.run_static_test(env, testCategory, "test-math.gc", get_test_pass_string("math", 31));
|
|
|
|
}
|
|
|
|
|
2020-10-24 22:51:40 -04:00
|
|
|
TEST(TypeConsistency, TypeConsistency) {
|
|
|
|
Compiler compiler;
|
|
|
|
compiler.enable_throw_on_redefines();
|
|
|
|
compiler.run_test_no_load("test/goalc/source_templates/with_game/test-build-game.gc");
|
|
|
|
compiler.run_test_no_load("decompiler/config/all-types.gc");
|
2020-11-28 19:59:23 -05:00
|
|
|
}
|