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, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
*//**
    @file
    Unit test functions for compiler. Nothing here yet.
*/
#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_FIXED("x");
    CHECK_FREE("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_FIXED("z");
    
    sim_destroy(sim);
    Asc_CompilerDestroy();
}

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

/* the list of tests */

#define TESTS(T) \
    T(test1) \
    T(test2)
    
REGISTER_TESTS_SIMPLE(compiler_fixfree, TESTS)

1	/* 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	along with this program; if not, write to the Free Software
16	Foundation, Inc., 59 Temple Place - Suite 330,
17	Boston, MA 02111-1307, USA.
18	//*
19	@file
20	Unit test functions for compiler. Nothing here yet.
21	*/
22	#include <string.h>
23
24	#include <ascend/general/env.h>
25	#include <ascend/general/platform.h>
26	#include <ascend/utilities/ascEnvVar.h>
27	#include <ascend/utilities/error.h>
28
29	#include <ascend/compiler/ascCompiler.h>
30	#include <ascend/compiler/module.h>
31	#include <ascend/compiler/parser.h>
32	#include <ascend/compiler/library.h>
33	#include <ascend/compiler/symtab.h>
34	#include <ascend/compiler/simlist.h>
35	#include <ascend/compiler/instquery.h>
36	#include <ascend/compiler/parentchild.h>
37	#include <ascend/compiler/atomvalue.h>
38
39	#include <ascend/compiler/initialize.h>
40
41	#include <test/common.h>
42	#include <test/assertimpl.h>
43
44	static struct Instance load_model(const char name){
45	struct module_t *m;
46	int status;
47
48	Asc_CompilerInit(1);
49	Asc_PutEnv(ASC_ENV_LIBRARY "=models");
50
51	/* load the file */
52	m = Asc_OpenModule("test/compiler/fixfree.a4c",&status);
53	CU_ASSERT(status == 0);
54
55	/* parse it */
56	CU_ASSERT(0 == zz_parse());
57
58	/* instantiate it */
59	struct Instance *sim = SimsCreateInstance(AddSymbol(name), AddSymbol("sim1"), e_normal, NULL);
60	CU_ASSERT_FATAL(sim!=NULL);
61
62	return sim;
63	}
64
65	#define GET_FIXED(VAR) \
66	inst = ChildByChar(root,AddSymbol(VAR)); \
67	CU_ASSERT_FATAL(inst!=NULL); \
68	CU_ASSERT((InstanceKind(inst)==REAL_ATOM_INST)); \
69	inst = ChildByChar(inst,AddSymbol("fixed")); \
70	CU_ASSERT_FATAL(inst!=NULL);
71
72	#define CHECK_FIXED(VAR) \
73	GET_FIXED(VAR);\
74	CU_ASSERT(GetBooleanAtomValue(inst));
75	#define CHECK_FREE(VAR) \
76	GET_FIXED(VAR);\
77	CU_ASSERT(!GetBooleanAtomValue(inst));
78
79
80	static void test_test1(void){
81	struct Instance *sim = load_model("test1");
82
83	/* check for vars and rels */
84	struct Instance *root = GetSimulationRoot(sim);
85	struct Instance *inst;
86
87	CHECK_FREE("x");
88	CHECK_FREE("y");
89	CHECK_FREE("z");
90
91	/** Call on_load */
92	struct Name *name = CreateIdName(AddSymbol("on_load"));
93	enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
94	CU_ASSERT(pe==Proc_all_ok);
95
96	CHECK_FIXED("x");
97	CHECK_FREE("y");
98	CHECK_FREE("z");
99
100	sim_destroy(sim);
101	Asc_CompilerDestroy();
102	}
103
104	static void test_test2(void){
105	struct Instance *sim = load_model("test2");
106
107	/* check for vars and rels */
108	struct Instance *root = GetSimulationRoot(sim);
109	struct Instance *inst;
110
111	CHECK_FREE("x");
112	CHECK_FREE("y");
113	CHECK_FREE("z");
114
115	/** Call on_load */
116	struct Name *name = CreateIdName(AddSymbol("on_load"));
117	enum Proc_enum pe = Initialize(GetSimulationRoot(sim),name,"sim1", ASCERR, WP_STOPONERR, NULL, NULL);
118	CU_ASSERT(pe!=Proc_all_ok);
119
120	CHECK_FREE("y");
121	CHECK_FIXED("x");
122	CHECK_FIXED("z");
123
124	sim_destroy(sim);
125	Asc_CompilerDestroy();
126	}
127
128	/===========================================================================/
129	/* Registration information */
130
131	/* the list of tests */
132
133	#define TESTS(T) \
134	T(test1) \
135	T(test2)
136
137	REGISTER_TESTS_SIMPLE(compiler_fixfree, TESTS)
138