compiler/test/test_fixfree.c

/*  ASCEND modelling environment
    Copyright (C) 2007 Carnegie Mellon University

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*//**
    @file
    Unit test functions for FIX and FREE argument lists, especially where
    there are invalid things in the list.
*/
#include <string.h>

#include <ascend/general/env.h>
#include <ascend/general/platform.h>
#include <ascend/utilities/ascEnvVar.h>
#include <ascend/utilities/error.h>

#include <ascend/compiler/ascCompiler.h>
#include <ascend/compiler/module.h>
#include <ascend/compiler/parser.h>
#include <ascend/compiler/library.h>
#include <ascend/compiler/symtab.h>
#include <ascend/compiler/simlist.h>
#include <ascend/compiler/instquery.h>
#include <ascend/compiler/parentchild.h>
#include <ascend/compiler/atomvalue.h>

#include <ascend/compiler/initialize.h>

#include <test/common.h>
#include <test/assertimpl.h>

static struct Instance *load_model(const char *name){
    struct module_t *m;
    int status;

    Asc_CompilerInit(1);
    Asc_PutEnv(ASC_ENV_LIBRARY "=models");

    /* load the file */
    m = Asc_OpenModule("test/compiler/fixfree.a4c",&status);
    CU_ASSERT(status == 0);

    /* parse it */
    CU_ASSERT(0 == zz_parse());

    /* instantiate it */
    struct Instance *sim = SimsCreateInstance(AddSymbol(name), AddSymbol("sim1"), e_normal, NULL);
    CU_ASSERT_FATAL(sim!=NULL);

    return sim;
}

#define GET_FIXED(VAR) \
    inst = ChildByChar(root,AddSymbol(VAR)); \
    CU_ASSERT_FATAL(inst!=NULL); \
    CU_ASSERT((InstanceKind(inst)==REAL_ATOM_INST)); \
    inst = ChildByChar(inst,AddSymbol("fixed")); \
    CU_ASSERT_FATAL(inst!=NULL);

#define CHECK_FIXED(VAR) \
    GET_FIXED(VAR);\
    CU_ASSERT(GetBooleanAtomValue(inst));
#define CHECK_FREE(VAR) \
    GET_FIXED(VAR);\
    CU_ASSERT(!GetBooleanAtomValue(inst));


static void test_test1(void){
    struct Instance *sim = load_model("test1");

    /* check for vars and rels */
    struct Instance *root = GetSimulationRoot(sim);
    struct Instance *inst;

    CHECK_FREE("x");
    CHECK_FREE("y");
    CHECK_FREE("z");

    /** Call on_load */
    struct Name *name = CreateIdName(AddSymbol("on_load"));
    enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
    CU_ASSERT(pe==Proc_all_ok);

    CHECK_FREE("x");
    CHECK_FIXED("y");
    CHECK_FREE("z");

    sim_destroy(sim);
    Asc_CompilerDestroy();
}

static void test_test2(void){
    struct Instance *sim = load_model("test2");

    /* check for vars and rels */
    struct Instance *root = GetSimulationRoot(sim);
    struct Instance *inst;

    CHECK_FREE("x");
    CHECK_FREE("y");
    CHECK_FREE("z");

    /** Call on_load */
    struct Name *name = CreateIdName(AddSymbol("on_load"));
    enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
    CU_ASSERT(pe!=Proc_all_ok);

    CHECK_FREE("y");
    CHECK_FIXED("x");
    CHECK_FREE("z"); /* we expect names after the wrong ones not to have been changed */

    sim_destroy(sim);
    Asc_CompilerDestroy();
}

static void test_test3(void){
    struct Instance *sim = load_model("test3");

    /* check for vars and rels */
    struct Instance *root = GetSimulationRoot(sim);
    struct Instance *inst;

    CHECK_FREE("x");
    CHECK_FREE("z");

    /** Call on_load */
    struct Name *name = CreateIdName(AddSymbol("on_load"));
    enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
    CU_ASSERT(pe!=Proc_all_ok);

    CHECK_FIXED("x");
    CHECK_FREE("z");

    sim_destroy(sim);
    Asc_CompilerDestroy();
}


/*===========================================================================*/
/* Registration information */

/* the list of tests */

#define TESTS(T) \
    T(test1) \
    T(test2) \
    T(test3)

REGISTER_TESTS_SIMPLE(compiler_fixfree, TESTS)

1	jpye	2397	/* ASCEND modelling environment
2			Copyright (C) 2007 Carnegie Mellon University
3
4			This program is free software; you can redistribute it and/or modify
5			it under the terms of the GNU General Public License as published by
6			the Free Software Foundation; either version 2, or (at your option)
7			any later version.
8
9			This program is distributed in the hope that it will be useful,
10			but WITHOUT ANY WARRANTY; without even the implied warranty of
11			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			GNU General Public License for more details.
13
14			You should have received a copy of the GNU General Public License
15	jpye	2649	along with this program. If not, see <http://www.gnu.org/licenses/>.
16	jpye	2397	//*
17			@file
18	jpye	2408	Unit test functions for FIX and FREE argument lists, especially where
19			there are invalid things in the list.
20	jpye	2397	*/
21			#include <string.h>
22
23			#include <ascend/general/env.h>
24			#include <ascend/general/platform.h>
25			#include <ascend/utilities/ascEnvVar.h>
26			#include <ascend/utilities/error.h>
27
28			#include <ascend/compiler/ascCompiler.h>
29			#include <ascend/compiler/module.h>
30			#include <ascend/compiler/parser.h>
31			#include <ascend/compiler/library.h>
32			#include <ascend/compiler/symtab.h>
33			#include <ascend/compiler/simlist.h>
34			#include <ascend/compiler/instquery.h>
35			#include <ascend/compiler/parentchild.h>
36			#include <ascend/compiler/atomvalue.h>
37
38			#include <ascend/compiler/initialize.h>
39
40			#include <test/common.h>
41			#include <test/assertimpl.h>
42
43			static struct Instance load_model(const char name){
44			struct module_t *m;
45			int status;
46
47			Asc_CompilerInit(1);
48			Asc_PutEnv(ASC_ENV_LIBRARY "=models");
49	jpye	2649
50	jpye	2397	/* load the file */
51			m = Asc_OpenModule("test/compiler/fixfree.a4c",&status);
52			CU_ASSERT(status == 0);
53
54			/* parse it */
55			CU_ASSERT(0 == zz_parse());
56
57			/* instantiate it */
58			struct Instance *sim = SimsCreateInstance(AddSymbol(name), AddSymbol("sim1"), e_normal, NULL);
59			CU_ASSERT_FATAL(sim!=NULL);
60
61			return sim;
62			}
63
64			#define GET_FIXED(VAR) \
65			inst = ChildByChar(root,AddSymbol(VAR)); \
66			CU_ASSERT_FATAL(inst!=NULL); \
67			CU_ASSERT((InstanceKind(inst)==REAL_ATOM_INST)); \
68			inst = ChildByChar(inst,AddSymbol("fixed")); \
69			CU_ASSERT_FATAL(inst!=NULL);
70
71			#define CHECK_FIXED(VAR) \
72			GET_FIXED(VAR);\
73			CU_ASSERT(GetBooleanAtomValue(inst));
74			#define CHECK_FREE(VAR) \
75			GET_FIXED(VAR);\
76			CU_ASSERT(!GetBooleanAtomValue(inst));
77
78
79			static void test_test1(void){
80			struct Instance *sim = load_model("test1");
81
82			/* check for vars and rels */
83			struct Instance *root = GetSimulationRoot(sim);
84			struct Instance *inst;
85
86			CHECK_FREE("x");
87			CHECK_FREE("y");
88			CHECK_FREE("z");
89
90			/** Call on_load */
91			struct Name *name = CreateIdName(AddSymbol("on_load"));
92			enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
93			CU_ASSERT(pe==Proc_all_ok);
94
95	jpye	2399	CHECK_FREE("x");
96			CHECK_FIXED("y");
97	jpye	2397	CHECK_FREE("z");
98	jpye	2649
99	jpye	2397	sim_destroy(sim);
100			Asc_CompilerDestroy();
101			}
102
103			static void test_test2(void){
104			struct Instance *sim = load_model("test2");
105
106			/* check for vars and rels */
107			struct Instance *root = GetSimulationRoot(sim);
108			struct Instance *inst;
109
110			CHECK_FREE("x");
111			CHECK_FREE("y");
112			CHECK_FREE("z");
113
114			/** Call on_load */
115			struct Name *name = CreateIdName(AddSymbol("on_load"));
116			enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
117			CU_ASSERT(pe!=Proc_all_ok);
118
119			CHECK_FREE("y");
120			CHECK_FIXED("x");
121	jpye	2399	CHECK_FREE("z"); /* we expect names after the wrong ones not to have been changed */
122	jpye	2649
123	jpye	2397	sim_destroy(sim);
124			Asc_CompilerDestroy();
125			}
126
127	jpye	2399	static void test_test3(void){
128			struct Instance *sim = load_model("test3");
129
130			/* check for vars and rels */
131			struct Instance *root = GetSimulationRoot(sim);
132			struct Instance *inst;
133
134			CHECK_FREE("x");
135			CHECK_FREE("z");
136
137			/** Call on_load */
138			struct Name *name = CreateIdName(AddSymbol("on_load"));
139			enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
140			CU_ASSERT(pe!=Proc_all_ok);
141
142			CHECK_FIXED("x");
143			CHECK_FREE("z");
144	jpye	2649
145	jpye	2399	sim_destroy(sim);
146			Asc_CompilerDestroy();
147			}
148
149
150	jpye	2397	/===========================================================================/
151			/* Registration information */
152
153			/* the list of tests */
154
155			#define TESTS(T) \
156			T(test1) \
157	jpye	2399	T(test2) \
158			T(test3)
159	jpye	2649
160	jpye	2397	REGISTER_TESTS_SIMPLE(compiler_fixfree, TESTS)
161