test_jlc_func_def_func_new.cpp

#include "typechecker/jlc_tc_udt_def.h"
#include "typechecker/jlc_tc_udt_dcl.h"
#include "typechecker/jlc_tc_func_dcl.h"
#include "typechecker/jlc_tc_func_def.h"
#include "common/jlc_context.h"
#include "common/test.h"

#include <iostream>
#include <string>

#define init_checker()                                              \
    auto parse_tree = gen_ast(input_str);                           \
    auto context = std::make_shared<JLC::CONTEXT::JLCContext>();    \
    auto type_decl_checker =                                        \
        std::make_shared<JLC::TC::JLC_UDT_DC_Checker>(context);     \
    auto func_decl_checker =                                        \
        std::make_shared<JLC::TC::JLC_FUNC_CD_Checker>(context);    \
    auto type_def_checker =                                         \
        std::make_shared<JLC::TC::JLC_TC_UDT_DEF_Checker>(context); \
    auto func_def_checker =                                         \
        std::make_shared<JLC::TC::JLC_FUNC_DEF_Checker>(context);

#define run_checker()                            \
    parse_tree->accept(type_decl_checker.get()); \
    parse_tree->accept(func_decl_checker.get()); \
    parse_tree->accept(type_def_checker.get());  \
    parse_tree->accept(func_def_checker.get());

int main(int argc, char **argv)
{
    // new struct
    {
        std::string input_str = "typedef struct A_t { int x; }* A;\n"
                                "void f(){ A a = new A_t;}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new a undefined struct type
    {
        std::string input_str = "void f(){ A a = new A_t;}";

        init_checker();

        // check the parse tree
        TEST_EXPECT_EXCEPTION(
            run_checker());
    }
    // new a class
    {
        std::string input_str = "class A { int x; }\n"
                                "void f(){ A a = new A;}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new a undefined class type
    {
        std::string input_str = "void f(){ A a = new A;}";

        init_checker();

        // check the parse tree
        TEST_EXPECT_EXCEPTION(
            run_checker());
    }
    // new basic type array
    {
        std::string input_str = "void f(){ int[] a = new int[10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new basic two dimension array
    {
        std::string input_str = "void f(){ int[][] a = new int[10][10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // invalid array size
    {
        std::string input_str = "void f(){ int[] a = new int[1.0];}";

        init_checker();

        // check the parse tree
        TEST_EXPECT_EXCEPTION(
            run_checker());
    }
    // invalid array size
    {
        std::string input_str = "double f2(){return 0.0;} \n"
                                "void f(){ int[][] a = new int[1][f2()];}";

        init_checker();

        // check the parse tree
        TEST_EXPECT_EXCEPTION(
            run_checker());
    }
    // new struct array
    {
        std::string input_str = "typedef struct A_t { int x; }* A;\n"
                                "void f(){ A[] a = new A[10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new class array
    {
        std::string input_str = "class A { int x; }\n"
                                "void f(){ A[] a = new A[10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new struct two dimension array
    {
        std::string input_str = "typedef struct A_t { int x; }* A;\n"
                                "void f(){ A[][] a = new A[10][10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new class two dimension array
    {
        std::string input_str = "class A { int x; }\n"
                                "void f(){ A[][] a = new A[10][10];}";

        init_checker();

        // check the parse tree
        run_checker();
    }
    // new struct array with invalid size
    {
        std::string input_str = "typedef struct A_t { int x; }* A;\n"
                                "void f(){ A[] a = new A[1.0];}";

        init_checker();

        // check the parse tree
        TEST_EXPECT_EXCEPTION(
            run_checker());
    }

    TEST_PASS();
}