TEST(ExpressionProduct, productExp)
{
TVP TEST_TRUE = newBool(true);
TVP result = productExp();
EXPECT_EQ (true,equals(TEST_TRUE,result));
recursiveFree(result);
recursiveFree (TEST_TRUE);
}
TEST(Expression_Map, mapApply)
{
TVP TEST_TRUE = newBool(true);
TVP result = mapApply();
EXPECT_EQ (true,equals(TEST_TRUE,result));
recursiveFree(result);
recursiveFree (TEST_TRUE);
}
TEST(Statements, recordR1)
{
TVP TEST_TRUE = newBool(true);
TVP result = recordR1();
EXPECT_EQ (true,equals(TEST_TRUE,result));
recursiveFree(result);
recursiveFree (TEST_TRUE);
}
TEST(Expression_Seq, seqLen)
{
int arr[] =
{ 1, 2 };
TVP t = newSequence(2,arr);
TVP res = vdmSeqLen(t);
EXPECT_EQ(2, res->value.intVal);
recursiveFree(res);
//
recursiveFree(t);
}
TEST(Expression_Map, mapDom)
{
//map1: {1|->2,3|->4,6|->7}
TVP map = createMap1();
//Get domain (returns a set)
TVP map_dom = vdmMapDom(map);
TVP res = vdmSetMemberOf(map_dom,newInt(3));
EXPECT_EQ(true, res->value.boolVal);
recursiveFree(map_dom);
recursiveFree(res);
}
TEST(Expression_Seq, seqTl)
{
int arr[] =
{ 1, 2 };
TVP t = newSequence(2,arr);
TVP res = vdmSeqTl(t);
struct Collection* col = (struct Collection*) res->value.ptr;
EXPECT_EQ(2, col->value[0]->value.intVal);
recursiveFree(res);
//
recursiveFree(t);
}
TEST(Expression_Seq, seqIndex)
{
int arr[] =
{ 1, 2 };
TVP t = newSequence(2,arr);
TVP index = newInt(2);
TVP res = vdmSeqIndex(t,index);
EXPECT_EQ(2, res->value.intVal);
recursiveFree(res);
//
recursiveFree(t);
recursiveFree(index);
}
void init(){
// Read the first line containing number of patients
int tmp ;
scanf("%d",&tmp);
// Read into binary tree
struct node * tree ;
int i = 0 ;
for ( i = 0 ; i < tmp ; i++){
if ( i == 0 ) tree = makeNode(readPatient());
else{
insert(&tree,readPatient());
}
}
// Read line containing number of queries.
scanf("%d",&tmp);
// Loop tmp number of times, reading the two queries, finding the query, and printing the value
for ( i = 0 ; i < tmp ; i++ ){
char * organQ = (char *)malloc(sizeof(char)*20);
char * bloodtypeQ = (char *)malloc(sizeof(char)*20);
organT * rtn = NULL ;
scanf("%s %s",organQ,bloodtypeQ);
getQuery(&rtn, tree,organQ,bloodtypeQ);
printPatient((rtn));
free(organQ);
free(bloodtypeQ);
free(rtn);
}
recursiveFree(tree);
}
TEST(Expression_Seq, seqInEqual)
{
int arr[] =
{ 1 };
TVP t = newSequence(1,arr);
int arr2[] =
{ 2 };
TVP t2 = newSequence(1,arr2);
TVP res = vdmSeqInEqual(t,t2);
EXPECT_EQ(true, res->value.boolVal);
recursiveFree(res);
//
recursiveFree(t);
recursiveFree(t2);
}
TEST(Expression_Seq, seqInds)
{
int arr[] =
{ 1, 2 };
TVP t = newSequence(2,arr);
TVP res = vdmSeqInds(t);
EXPECT_EQ(VDM_SET, res->type);
struct Collection* col = (struct Collection*) res->value.ptr;
EXPECT_TRUE(VDM_SET == res->type);
//TODO this is actually not the VDM version of inds [1,2] = {1,2}, the second set and the set,set comp is missing, I didnt do sets yet
EXPECT_TRUE(2 == col->value[0]->value.intVal || 2 == col->value[1]->value.intVal);
EXPECT_TRUE(1 == col->value[0]->value.intVal || 1 == col->value[1]->value.intVal);
recursiveFree(res);
//
recursiveFree(t);
}
TEST(Expression_Seq, seqConc)
{
int arr[] =
{ 1 };
TVP t = newSequence(1,arr);
int arr2[] =
{ 2 };
TVP t2 = newSequence(1,arr2);
TVP res = vdmSeqConc(t,t2);
struct Collection* col = (struct Collection*) res->value.ptr;
EXPECT_EQ(1, col->value[0]->value.intVal);
EXPECT_EQ(2, col->value[1]->value.intVal);
recursiveFree(res);
//
recursiveFree(t);
recursiveFree(t2);
}
TEST(Expression_Seq, seqElems)
{
int arr[] =
{ 1, 2 };
TVP t = newSequence(2,arr);
TVP a = newInt(1);
TVP b = newInt(2);
TVP elems = newSetVar(2, a,b);
TVP res = vdmSeqElems(t);
TVP tmp = vdmEquals(res,elems);
EXPECT_EQ(true, tmp->value.boolVal);
recursiveFree(res);
vdmFree(a);
vdmFree(b);
vdmFree(tmp);
vdmFree(elems);
//
recursiveFree(t);
}
void ObjectMemory::EmptyZct()
{
if (m_bIsReconcilingZct)
__debugbreak();
#ifdef _DEBUG
nDeleted = 0;
if (!alwaysReconcileOnAdd || Interpreter::executionTrace)
CHECKREFSNOFIX
else
checkStackRefs();
#endif
// Bump the refs from the stack. Any objects remaining in the ZCT with zero counts
// are truly garbage.
Interpreter::IncStackRefs();
OTE** pZct = m_pZct;
// This tells us that we are in the process of reconcilation
m_bIsReconcilingZct = true;
const int nOldZctEntries = m_nZctEntries;
m_nZctEntries = -1;
for (int i=0;i<nOldZctEntries;i++)
{
OTE* ote = pZct[i];
if (!ote->isFree() && ote->m_flags.m_count == 0)
{
// Note that deallocate cannot make new Zct entries
// Because we have bumped the ref. counts of all stack ref'd objects, only true
// garbage objects can ever have a ref. count of zero. Therefore if recursively
// counting down throws up new zero ref. counts, these should not be added to
// the Zct, but deallocated. To achieve this we set a global flag to indicate
// that we are reconciling, see AddToZct() above.
#ifdef _DEBUG
nDeleted++;
#endif
recursiveFree(ote);
}
}
// CHECKREFSNOFIX
}
TVP productExp()
{
TVP tmp1 = newProduct(2);
TVP tmp1_1 = newInt(1);
productSet(tmp1,1,tmp1_1);
recursiveFree(tmp1_1);
TVP tmp1_2 = newInt(2);
productSet(tmp1,2,tmp1_2);
recursiveFree(tmp1_2);
TVP tmp2_1 = newInt(1);
TVP tmp2_2 = newInt(2);
TVP args[2] = {tmp2_1,tmp2_2};
TVP tmp2 = newProductWithValues(2,args);
recursiveFree(tmp2_1);
recursiveFree(tmp2_2);
//
// TVP tmp2_1 = newInt(1);
// productSet(tmp2,1,tmp2_1);
// recursiveFree(tmp2_1);
//
// TVP tmp2_2 = newInt(2);
// productSet(tmp2,2,tmp2_2);
// recursiveFree(tmp2_2);
TVP res =newBool(equals(tmp1,tmp2));
//scope cleanup
recursiveFree(tmp1);
recursiveFree(tmp2);
return res;
}
// Count down and deallocate an Object - only performed when reconciling
// the Zct.
//
void ObjectMemory::recursiveCountDown(OTE* ote)
{
if (ote->decRefs())
recursiveFree(ote);
}
void Trie::recursiveFree(Node* node){
for(int i=0; i<branches; i++)
if(node->children[i]!=NULL)
recursiveFree(node->children[i]);
delete node;
}
// Memory
Trie::~Trie(){
recursiveFree(root);
}
