/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/unit-tests/BFIGGeneratorTester.h

//
// Copyright (c) 2004           Model-based Embedded and Robotic Systems Group
// All Rights Reserved          Massachusetts Institute of Technology
//
// This software is provided as is. Model-based Embedded and Robotic Systems
// (MERS) group does not assume any responsibility.
//
// Organization:        Model-based Embedded and Robotic Systems Group
//                                      Massachusetts Institute of Technology
//

#ifndef GENERATOR_TESTER_HEADER_FILE
#define GENERATOR_TESTER_HEADER_FILE

#include "BFIGHelper.h"

#include <tut.h>
#include <Mers/Generators/BFIG/BFIGGenerator.h>
#include <Mers/Models/Base/BaseModelDomainArray.h>
#include <Mers/Utils/Containers/IntegerArray.h>
#include <Mers/Utils/Logging/logger.h>

using Mers::Generators::BFIG::BFIGGenerator;
using log4cplus::Logger;

namespace tut {

        class BFIGGeneratorTester : public BFIGHelper
        {
        public:
                BFIGGeneratorTester();

                virtual ~BFIGGeneratorTester();

        protected:
                void initBFIGGenTest(unsigned int numDomains, 
                        const struct BFIGDomainEntry * domains,
                        bool isProbabilities,
                        unsigned int numVariables, 
                        const struct BFIGVariableEntry * variables,
                        double cutoffCost = 1e10) throw();

                template<int n> void testBFIG(unsigned int numberOfIConf,
                                                                                                                                        const unsigned int initialConflictsData[][n],
                                                                                                                                        unsigned int numberOfResults, 
                                                                                                                                        const unsigned int expectedResultsData[][n],
                                                                                                                                        const unsigned int runtimeConflictsData[][n],
                                                                                                                                        const bool acceptList[], 
                                                                                                                                        bool verifyTermination = true)
                {
                        long maximumVisitedStateCount = 10000000;
                        long maxSize = 10000000;
                        bool expand = true;

                        Logger log = Logger::getInstance(
                                "Mers.Generators.BFIG.unit-tests.BFIGGeneratorTester");

                        LOG4CPLUS_DEBUG_STR(log, "*** Testing BFIG ***");
                        LOG4CPLUS_DEBUG(log, "*** With " << numberOfIConf
                                << " initial conflicts and " << numberOfResults
                                << " expected results.");

                        ensure("BFIG Generator != NULL", mGenerator != NULL);
                        
                        std::vector<Mers::Models::Base::BaseModelAssignmentArray *> expectedResults;
                        std::vector<Mers::Models::Base::BaseModelAssignmentArray *> initialConflicts;
                        std::vector<Mers::Models::Base::BaseModelAssignmentArray *> runtimeConflicts;

                        loadAssignments(expectedResults, numberOfResults, expectedResultsData);
                        loadAssignments(initialConflicts, numberOfIConf, initialConflictsData);
                        loadAssignments(runtimeConflicts, numberOfResults, runtimeConflictsData);

#ifdef VERBOSE
                        cout << endl << "Running with Initial Conflicts" << endl;
                        for(unsigned int i = 0; i < initialConflicts.size(); i++) {
                                initialConflicts[i]->printArray(cout, ", ");
                                cout << endl;
                        }
                        cout << "Runtime Data" << endl;
                        for(unsigned int i = 0; i < runtimeConflicts.size(); i++) {
                                cout << "Conf: ";
                                runtimeConflicts[i]->printArray(cout, ", ");
                                cout << "; Exp Res: ";
                                expectedResults[i]->printArray(cout, ", ");
                                cout << "; " << (acceptList[i] ? "Accept" : "Reject") << endl;
                        }
#endif
                        

                        ensure_equals("Expected number of results",
                                expectedResults.size(), numberOfResults);
                        ensure_equals("Expected number of initial conflicts",
                                initialConflicts.size(), numberOfIConf);
                        ensure_equals("Expected number of runtime conflicts",
                                runtimeConflicts.size(), numberOfResults);

                        for(unsigned int c = 0; c < initialConflicts.size(); c++)
                        {
                                mGenerator->addConflict(initialConflicts[c]);
                        }

                        for(unsigned int s = 0; s < expectedResults.size(); s++)
                        {
                                // Get the next solution.
                                Mers::Models::Base::BaseModelAssignmentArray const * actualSolution = 
                                        mGenerator->generateBestImplicant(maximumVisitedStateCount, 
                                        maxSize, expand);
                                // Get the next expected solution.
                                Mers::Models::Base::BaseModelAssignmentArray const * expectedSolution =
                                        expectedResults[s];

                                ensure("Expecting another solution", actualSolution != NULL);
                                ensure_equals("Expected full solution length is as reported",
                                                                                        expectedSolution->getLength(),
                                                                                        mGenerator->getFullAssignmentSize());
                                ensure_equals("Actual full solution length is reported",
                                                                                        actualSolution->getLength(),
                                                                                        mGenerator->getFullAssignmentSize());
                                ensure_equals("Generated Solution", 
                                                                                        *actualSolution, *expectedSolution);

#ifdef VERBOSE
                                cout << "Solution: ";
                                actualSolution->printArray(cout, ", ");
                                cout << endl;
#endif

                                // Mark this candidate if we're supposed to.
                                if(acceptList[s]) {
                                        mGenerator->markBestFeasible();

#ifdef VERBOSE
                                        cout << "Marked" << endl;
#endif
                                }
                                // Add new conflicts, if present (this means we're disallowing
                                // the empty conflict).
                                if(runtimeConflicts[s]->getLength() > 0) {
                                        mGenerator->addConflict(runtimeConflicts[s]);

#ifdef VERBOSE
                                        cout << "Conflict: ";
                                        runtimeConflicts[s]->printArray(cout, ", ");
                                        cout << endl;
#endif
                                }
                        }

                        if(verifyTermination) {
                                ensure("No additional solutions",
                                        mGenerator->generateBestImplicant(maximumVisitedStateCount, 
                                        maxSize, expand) == NULL);

#ifdef VERBOSE
                                cout << "All Done" << endl;
#endif
                        }

                        for(unsigned int s = 0; s < expectedResults.size(); s++)
                                delete expectedResults[s];
                        for(unsigned int s = 0; s < initialConflicts.size(); s++)
                                delete initialConflicts[s];
                        for(unsigned int s = 0; s < runtimeConflicts.size(); s++)
                                delete runtimeConflicts[s];

                        LOG4CPLUS_DEBUG_STR(log, "*** BFIG Test Complete");
                }

        protected:
                BFIGGenerator * mGenerator;
        };

}

#endif

---