root/ggpa/TestSentence.cpp

/*
 * TestSentence.cpp
 */

#include "TestTools.h"
#include "Sentence.h"

vector<string> values, values2, values3;
SentenceStructure *structure = NULL, *structure2 = NULL;
Sentence *sentence = NULL, *sentence2 = NULL, *sentence3 = NULL;

void testConstructor() {
    //testing constructor
    cout << "Testing Constructor... ";
    assertTrue(sentence->getStructure() ==  structure,
               "Structures don't match");
    cout << "Passed" << endl;
}

void testAtomicSentences() {
    //testing getAtomicSentences() and getIndex()
    cout << "Testing getAtomicSentences and getIndex... ";
    vector<Sentence*> atomicSentences = sentence3->getAtomicSentences();
    int theIndex;
    assertEquals(9, atomicSentences.size(), "Atomic Sentence size failed.");

    // print the atomic sentences
    for (unsigned int i = 0; i < atomicSentences.size(); i++) {
        cout << atomicSentences[i]->getName() << " ";
        for (unsigned int j = 0; j < atomicSentences[i]->getNumValues(); j++) {
            cout << (*(atomicSentences[i]))[j] << " ";
        }
        cout << endl;
    }

    int step = 1;
    unsigned int value = structure2->getOffset();
    if (ENDIAN == BIG_ENDIAN) {
        step = 3;
    }
    for(unsigned int i = 0; i < atomicSentences.size(); 
        i++, value += step)
    {
        theIndex = atomicSentences[i]->getIndex();
        assertEquals(value, theIndex, "Index test failed.");
    }
    cout << "Passed" << endl;
}

void testDependencies() {
    //testing dependencies
    cout << "Testing dependencies... " << endl;
    sentence->addAndDependency(sentence2, true);
    sentence->addAndDependency(sentence3, false);

    assertEquals(1, sentence->isDependencyNegated(0),
                 "Negation test failed.");
    assertEquals(0, sentence->isDependencyNegated(1),
                 "Negation test2 failed.");
    vector<vector<Sentence*> > dependencies = sentence->getDependencies();
    assertTrue(dependencies[0][0] == sentence2,
                        "Dependency test 1 failed.");
    assertTrue(dependencies[1][0] == sentence3,
                        "Dependency test 2 failed.");

    vector<Sentence*> orDependency;
    orDependency.push_back(sentence);
    orDependency.push_back(sentence3);
    sentence2->addOrDependency(orDependency, true);

    vector<vector<Sentence*> > dependencies2 = sentence2->getDependencies();
    assertTrue(dependencies2[0][0] == sentence, 
               "Dependency test 3 failed.");
    assertTrue(dependencies2[0][1] == sentence3,
               "Dependency test 4 failed.");

    // cleanup
    sentence->clearDependencies(false);
    sentence2->clearDependencies(false);

    cout << "Passed" << endl;
}

void testGetVariables() {
    cout << "Running getVariables test...";

    map<string, vector<string> > variableMap;
    
    variableMap = sentence3->getVariables();
    
    cout << "Testing";

    assertEquals(variableMap.size(), 2, "VariableMap has the wrong size");
    
    assertEquals(variableMap["?x"].size(), 3, 
                 "Size was incorrect for variable '?x'"); 
    assertTrue(variableMap["?x"] == structure2->getValues(0), 
               "Variables for ?x were incorrect");
    assertEquals(variableMap["?y"].size(), 3, 
                 "Size was incorrect for variable '?y'");
    assertTrue(variableMap["?y"] == structure2->getValues(1), 
               "Variables for ?y were incorrect");
    assertEquals(variableMap["x"].size(), 0, "Values for 'x' was not empty");

    // test with dependencies
    sentence2->addAndDependency(sentence3, false);

    variableMap = sentence2->getVariables();

    assertEquals(variableMap.size(), 4, "VariableMap has the wrong size");
    
    assertEquals(variableMap["?x"].size(), 3, 
                 "Size was incorrect for variable '?x'"); 
    assertTrue(variableMap["?x"] == structure2->getValues(0), 
               "Variables for ?x were incorrect");
    assertEquals(variableMap["?y"].size(), 3, 
                 "Size was incorrect for variable '?y'");
    assertTrue(variableMap["?y"] == structure2->getValues(1), 
               "Variables for ?y were incorrect");
    assertEquals(variableMap["x"].size(), 0, "Values for 'x' was not empty");
    assertEquals(variableMap["?a"].size(), 3, 
                 "Size was incorrect for variable '?a'"); 
    assertTrue(variableMap["?a"] == structure2->getValues(0), 
               "Variables for ?a were incorrect");
    assertEquals(variableMap["?b"].size(), 3, 
                 "Size was incorrect for variable '?b'");
    assertTrue(variableMap["?b"] == structure2->getValues(1), 
               "Variables for ?b were incorrect");
    assertEquals(variableMap["b"].size(), 0, "Values for 'b' was not empty");

    // test with or dependency
    sentence2->clearDependencies(false);
    vector<Sentence*> orDependency;
    orDependency.push_back(sentence);
    orDependency.push_back(sentence3);
    sentence2->addOrDependency(orDependency, true);

    variableMap = sentence2->getVariables();

    assertEquals(variableMap.size(), 4, "VariableMap has the wrong size");
    
    assertEquals(variableMap["?x"].size(), 3, 
                 "Size was incorrect for variable '?x'"); 
    assertTrue(variableMap["?x"] == structure2->getValues(0), 
               "Variables for ?x were incorrect");
    assertEquals(variableMap["?y"].size(), 3, 
                 "Size was incorrect for variable '?y'");
    assertTrue(variableMap["?y"] == structure2->getValues(1), 
               "Variables for ?y were incorrect");
    assertEquals(variableMap["x"].size(), 0, "Values for 'x' was not empty");
    assertEquals(variableMap["?a"].size(), 3, 
                 "Size was incorrect for variable '?a'"); 
    assertTrue(variableMap["?a"] == structure2->getValues(0), 
               "Variables for ?a were incorrect");
    assertEquals(variableMap["?b"].size(), 3, 
                 "Size was incorrect for variable '?b'");
    assertTrue(variableMap["?b"] == structure2->getValues(1), 
               "Variables for ?b were incorrect");
    assertEquals(variableMap["b"].size(), 0, "Values for 'b' was not empty");

    sentence2->clearDependencies(false);

    
    cout << "Done" << endl;
    
}

int main(void)
{
    
    cout << "***** Running Tests *****" << endl;
    // set up values
    values.push_back("1");
    values.push_back("2");
    values2.push_back("?a");
    values2.push_back("?b");
    values2.push_back("b");
    values3.push_back("?x");
    values3.push_back("?y");
    values3.push_back("x");

    structure = new SentenceStructure("succ", 2, true);
    structure2= new SentenceStructure("cell", 3, false);
    structure->setOffset(0);
    structure->addValue(0, "0");
    structure->addValue(0, "1");
    structure->addValue(1, "0");
    structure->addValue(1, "1");
    structure->addValue(1, "2");

    structure2->setOffset(6);
    structure2->addValue(0, "0");
    structure2->addValue(0, "1");
    structure2->addValue(0, "2");
    structure2->addValue(1, "0");
    structure2->addValue(1, "1");
    structure2->addValue(1, "2");
    structure2->addValue(2, "x");
    structure2->addValue(2, "o");
    structure2->addValue(2, "b");

    sentence = new Sentence(values, structure);
    sentence2 = new Sentence(values2, structure2);
    sentence3 = new Sentence(values3, structure2);

    //sentence3->print();

    // run the tests
    testConstructor();
    testAtomicSentences();
    testDependencies();
    testGetVariables();
    cout << "check" << endl;
    

    cout << "***** Tests Passed! *****" << endl;
}