int main (int argc, char * argv[])
{
try {
std::ifstream doc("test.xqm", std::ios_base::binary);
if(argc == 2 && std::string(argv[1]) == "-t") {
std::ifstream mapfile("test.xqa", std::ios_base::binary);
std::ofstream output("test.xml");
std::cerr<<"Parsing with translation enabled... ";
output<<"<?xml version=\"1.0\"?>\n";
xqML::Parser myparser(mapfile, doc, output);
myparser.parseDocument();
std::cerr<<"done\n\tSee file \"test.xml\" for an xml-like output (viewable in Mozilla/IE)\n";
}
else if (argc == 1) {
std::ofstream output("test.dat");
std::cerr<<"Parsing with translation disabled... ";
xqML::Parser myparser(doc, output);
myparser.parseDocument();
std::cerr<<"done\n\tSee file \"test.dat\" for an xml-like output with numbers instead of identifiers\n";
}
else {
std::cerr<<"Usage: parser_test [-t]\n";
std::cerr<<" Options:\n";
std::cerr<<" -t\tenable translation\n";
}
}
catch (xqML::IllegalIdentifier exception) {
std::cerr<<"Illegal Identifier "<<exception.identifier<<" of type "<<exception.type<<"\n";
}
catch (xqML::IllegalContext exception) {
std::cerr<<"Illegal Context \""<<exception.context<<"\" while writing \""<<exception.identifier<<"\" of type "<<exception.type<<'\n';
}
catch (...) {
std::cerr<<"Caught unknown exception, aborting :-(\n";
std::abort();
}
return 0;
}
void test_xml_parser::Run()
{
TestBegin();
XMLParser myparser((char *) "configuration.xml");
std::string value;
bool status = false;
try
{
mTestsRun++;
if(myparser.parseXML() == ERROR)
{
std::cout << "failed to parse the xml " << std::endl;
return;
}
else
mTestsPassed++;
// myparser.PrintMap();
}
catch(...)
{
std::cout << "caught error" <<std::endl;
}
mTestsRun++;
if (myparser.find("/configuration/nasdaq/name").compare("Nasdaq") == 0)
status = true;
else
{
std::cout << "could not find /configuration/nasdaq/name" << std::endl;
}
if(status) // if we passed part one continue to part 2.
{
if(myparser.find("/configuration/nasdaq/sources/database/host").compare("mm1.local") == 0 )
status = true;
else
{
std::cout << "could not find /configuration/nasdaq/sources/database/host" << std::endl;
}
}
/* if part one or part two failed the test failed else we passed*/
if(status)
mTestsPassed++;
TestEnd();
return;
}
int main()
{
BackTrackSolver<double> GBTS; /* Generic Backtracker */
PCSolver<double> GPCS; /* Generic Solver */
Solution<double> S1;
struct pc_pc_set pcs;
VCSet vc_set;
pc_init_pcset(&pcs);
fastf_t D = 8.04;
point_t E = {8.04, 3.2, 0.0};
vect_t F = {5.4, 3.6, 4.4};
pc_pushparam_struct(&pcs, "D", PC_DB_FASTF_T, &D);
pc_pushparam_struct(&pcs, "E", PC_DB_POINT_T, &E);
pc_pushparam_struct(&pcs, "G", PC_DB_VECTOR_T, &F);
const char *args[] = { "F", "G" };
pc_pushconstraint_expr(&pcs, "Constraint-test", "A + B < 0");
pc_pushparam_struct(&pcs, "F", PC_DB_VECTOR_T, &F);
pc_constrnt *con;
pc_mk_isperpendicular(&con, "G _|_ F", args);
pc_pushconstraint_struct(&pcs, "Struct-test", 2, 3, &pc_isperpendicular, args);
pc_free_constraint(con);
Parser myparser(vc_set); /* generate vc_set from pcs using parser */
myparser.parse(&pcs);
/* modify/access parameter property in vc_set using getParameter */
vc_set.getParameter("G")->setConst(true);
/* Two solution methods*/
vc_set.display();
GBTS.solve(vc_set, S1);
std::cout << "\nSolution using Generic BackTracking Solver "
<< GBTS.numChecks() << "\t" << GBTS.numSolutions() << std::endl;
S1.display();
S1.clear();
vc_set.display();
GPCS.solve(vc_set, S1);
std::cout << "\nSolution using Generic Solver "
<< GPCS.numChecks() << "\t" << GPCS.numSolutions() << std::endl;
S1.cdisplay();
pc_free_pcset(&pcs);
#if 0
/** Testing PCSolver Methods */
VCSet myvcset;
Solution<int> S;
/* add Variables to VCSet */
myvcset.addVariable<int>("A", 1, 0, 5, 1);
myvcset.addVariable<int>("B", 3, 0, 5, 1);
myvcset.addVariable<int>("C", 2, 0, 5, 1);
myvcset.addVariable<int>("D", 0, 0, 5, 1);
/* add Constraints to VCSet */
myvcset.addConstraint("0", "A * B = 12", f1, 2, "A", "B");
myvcset.addConstraint("1", "B + C < 5", f2, 2, "B", "C");
myvcset.addConstraint("2", "A - D = 2", f3, 2, "A", "D");
myvcset.addConstraint("3", "A * C = 4", f4, 2, "A", "C");
myvcset.display();
BinaryNetwork<int > N(myvcset);
N.display();
GTSolver<int> GTS;
BackTrackSolver<int> BTS;
PCSolver<int> PCS;
std::cout << "-----------------------------" << std::endl;
GTS.solve(N, S);
std::cout << "Solution using Generate-Test" << std::endl;
S.display();
S.clear();
std::cout << "-----------------------------" << std::endl;
BTS.solve(myvcset, S);
std::cout << "Solution using BackTracking" << std::endl;
S.display();
S.clear();
std::cout << "-----------------------------" << std::endl;
PCS.solve(myvcset, S);
std::cout << "Solution using Generic GT Solver" << std::endl;
S.display();
std::cout << "-----------------------------" << std::endl;
std::cout << "Number of Constraint checks performed" << std::endl;
std::cout << "Generate-Test:" << GTS.numChecks() << std::endl;
std::cout << "BackTracking based:" << BTS.numChecks() << std::endl;
std::cout << "Generic Generate-Test:" << PCS.numChecks() << std::endl;
#endif
return 0;
}
