#include <cppunit/TestFixture.h>
#include <cppunit/TestAssert.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/CompilerOutputter.h>
#include <iostream>
#include <vector>
#include "AttrTable.h"
#include "GetOpt.h"
using std::cerr;
using std::endl;
using std::vector;
using namespace CppUnit;
using namespace libdap;
int test_variable_sleep_interval = 0; // Used in Test* classes for testing
// timeouts.
static bool debug = false;
class attrTableT: public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE (attrTableT);
CPPUNIT_TEST(attrTableT_test);CPPUNIT_TEST_SUITE_END( )
;
private:
/* TEST PRIVATE DATA */
public:
void setUp()
{
}
void tearDown()
{
}
void attrTableT_test()
{
AttrTable at;
unsigned int at_size = at.get_size();
CPPUNIT_ASSERT(at_size == 0);
string at_name = at.get_name();
CPPUNIT_ASSERT(at_name == "");
at.set_name("My Attributes");
at_name = at.get_name();
CPPUNIT_ASSERT(at_name == "My Attributes");
AttrTable *container = at.find_container("dummy_container");
CPPUNIT_ASSERT(!container);
AttrTable *dummy_at = 0;
AttrTable::Attr_iter iter;
at.find("dummy_attr", &dummy_at, &iter);
CPPUNIT_ASSERT(iter == at.attr_end());
string attr_name = "attr1";
string attr_type = "string";
string attr_value = "attr1Value1";
at.append_attr(attr_name, attr_type, attr_value);
attr_name = "attr2";
attr_type = "string";
attr_value = "attr2Value1";
at.append_attr(attr_name, attr_type, attr_value);
attr_name = "attr3";
attr_type = "string";
attr_value = "attr3Value1";
at.append_attr(attr_name, attr_type, attr_value);
at.append_attr("attr4", "string", "attr4Value1");
at_size = at.get_size();
CPPUNIT_ASSERT(at_size == 4);
//at.print( stdout ) ;
iter = at.attr_end();
at.find("attr3", &dummy_at, &iter);
CPPUNIT_ASSERT(iter != at.attr_end());
iter = at.attr_end();
at.find("dummy_attr", &dummy_at, &iter);
CPPUNIT_ASSERT(iter == at.attr_end());
attr_type = at.get_type("attr3");
CPPUNIT_ASSERT(attr_type == "String");
AttrType attr_type_enum = at.get_attr_type("attr3");
CPPUNIT_ASSERT(attr_type_enum == Attr_string);
unsigned int num_attrs = at.get_attr_num("attr3");
CPPUNIT_ASSERT(num_attrs == 1);
attr_value = at.get_attr("attr3");
CPPUNIT_ASSERT(attr_value == "attr3Value1");
at.append_attr("attr3", "string", "attr3Value2");
at.append_attr("attr3", "string", "attr3Value3");
at.append_attr("attr3", "string", "attr3Value4");
attr_value = at.get_attr("attr3");
CPPUNIT_ASSERT(attr_value == "attr3Value1");
vector<string> sb;
sb.push_back("attr3Value1");
sb.push_back("attr3Value2");
sb.push_back("attr3Value3");
sb.push_back("attr3Value4");
typedef vector<string>::const_iterator str_citer;
typedef vector<string>::iterator str_iter;
vector<string> *values = at.get_attr_vector("attr3");
CPPUNIT_ASSERT(values);
if (values) {
str_citer vi = values->begin();
str_citer sbi = sb.begin();
for (; vi != values->end() && sbi != sb.end(); vi++, sbi++) {
CPPUNIT_ASSERT((*vi) == (*sbi));
}
CPPUNIT_ASSERT(vi == values->end() && sbi == sb.end());
if (vi == values->end() && sbi != sb.end()) {
CPPUNIT_FAIL("not enough values");
}
else if (vi != values->end() && sbi == sb.end()) {
CPPUNIT_FAIL("too many values");
}
}
vector<string> attrs;
attrs.push_back("attr1");
attrs.push_back("attr2");
attrs.push_back("attr3");
attrs.push_back("attr4");
str_citer ai = attrs.begin();
AttrTable::Attr_iter i = at.attr_begin();
// ai = attrs.begin() ;
for (; i != at.attr_end() && ai != attrs.end(); i++, ai++) {
CPPUNIT_ASSERT((*i)->name == (*ai));
}
CPPUNIT_ASSERT(i == at.attr_end() && ai == attrs.end());
if (i != at.attr_end() && ai == attrs.end()) {
CPPUNIT_FAIL("too many attributes");
}
else if (i == at.attr_end() && ai != attrs.end()) {
CPPUNIT_FAIL("not enough attributes");
}
iter = at.attr_end();
at.find("attr3", &dummy_at, &iter);
CPPUNIT_ASSERT(iter != at.attr_end());
attr_name = at.get_name(iter);
CPPUNIT_ASSERT(attr_name == "attr3");
bool isit = at.is_container(iter);
CPPUNIT_ASSERT(isit == false);
dummy_at = at.get_attr_table(iter);
CPPUNIT_ASSERT(!dummy_at);
attr_type = at.get_type(iter);
CPPUNIT_ASSERT(attr_type == "String");
attr_type_enum = at.get_attr_type(iter);
CPPUNIT_ASSERT(attr_type_enum == Attr_string);
attr_value = at.get_attr(iter);
CPPUNIT_ASSERT(attr_value == "attr3Value1");
attr_value = at.get_attr(iter, 1);
CPPUNIT_ASSERT(attr_value == "attr3Value2");
values = at.get_attr_vector(iter);
CPPUNIT_ASSERT(values);
if (values) {
str_citer vi = values->begin();
str_citer sbi = sb.begin();
for (; vi != values->end() && sbi != sb.end(); vi++, sbi++) {
CPPUNIT_ASSERT((*vi) == (*sbi));
}
CPPUNIT_ASSERT(vi == values->end() && sbi == sb.end());
if (vi == values->end() && sbi != sb.end()) {
CPPUNIT_FAIL("not enough values");
}
else if (vi != values->end() && sbi == sb.end()) {
CPPUNIT_FAIL("too many values");
}
}
{
str_iter sbi = sb.begin();
sbi++;
sb.erase(sbi);
}
at.del_attr("attr3", 1);
values = at.get_attr_vector(iter);
CPPUNIT_ASSERT(values);
if (values) {
str_citer vi = values->begin();
str_citer sbi = sb.begin();
for (; vi != values->end() && sbi != sb.end(); vi++, sbi++) {
CPPUNIT_ASSERT((*vi) == (*sbi));
}
CPPUNIT_ASSERT(vi == values->end() && sbi == sb.end());
if (vi == values->end() && sbi != sb.end()) {
CPPUNIT_FAIL("not enough values");
}
else if (vi != values->end() && sbi == sb.end()) {
CPPUNIT_FAIL("too many values");
}
}
at.del_attr("attr3");
container = 0;
try {
container = at.append_container("attr2");
CPPUNIT_FAIL("added container named attr2 successfully - already exists");
}
catch (Error &e) {
}
CPPUNIT_ASSERT(!container);
try {
container = at.append_container("attr5");
}
catch (Error &e) {
CPPUNIT_FAIL("failed to add new container attr5");
}
CPPUNIT_ASSERT(container);
if (container) {
CPPUNIT_ASSERT(container->get_name() == "attr5");
}
container = at.find_container("attr5");
CPPUNIT_ASSERT(container);
if (container) {
string container_name = container->get_name();
CPPUNIT_ASSERT(container_name == "attr5");
}
iter = at.attr_end();
at.find("attr5", &dummy_at, &iter);
CPPUNIT_ASSERT(iter != at.attr_end());
attr_name = at.get_name(iter);
CPPUNIT_ASSERT(attr_name == "attr5");
isit = at.is_container(iter);
CPPUNIT_ASSERT(isit == true);
container = at.get_attr_table(iter);
CPPUNIT_ASSERT(container);
attr_type = at.get_type(iter);
CPPUNIT_ASSERT(attr_type == "Container");
attr_type_enum = at.get_attr_type(iter);
CPPUNIT_ASSERT(attr_type_enum == Attr_container);
/* FIX: does append attr return anything? */
container->append_attr("attr5-1", "string", "attr5.1Value1");
container->append_attr("attr5-2", "string", "attr5.2Value1");
container->append_attr("attr5-3", "string", "attr5.3Value1");
container->append_attr("attr5-4", "string", "attr5.4Value1");
iter = at.attr_end();
at.find("attr5.attr5-3", &dummy_at, &iter);
CPPUNIT_ASSERT(iter != at.attr_end());
CPPUNIT_ASSERT(container == dummy_at);
//at.print( stdout ) ;
}
};
CPPUNIT_TEST_SUITE_REGISTRATION(attrTableT);
/* NOTHING NEEDS TO BE CHANGED BELOW HERE */
int main(int argc, char *argv[])
{
GetOpt getopt(argc, argv, "dh");
int option_char;
while ((option_char = getopt()) != -1)
switch (option_char) {
case 'd':
debug = 1; // debug is a static global
break;
case 'h': { // help - show test names
cerr << "Usage: attrTableT has the following tests:" << endl;
const std::vector<Test*> &tests = attrTableT::suite()->getTests();
unsigned int prefix_len = attrTableT::suite()->getName().append("::").length();
for (std::vector<Test*>::const_iterator i = tests.begin(), e = tests.end(); i != e; ++i) {
cerr << (*i)->getName().replace(0, prefix_len, "") << endl;
}
break;
}
default:
break;
}
CppUnit::TextTestRunner runner;
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
bool wasSuccessful = true;
string test = "";
int i = getopt.optind;
if (i == argc) {
// run them all
wasSuccessful = runner.run("");
}
else {
for (; i < argc; ++i) {
if (debug) cerr << "Running " << argv[i] << endl;
test = attrTableT::suite()->getName().append("::").append(argv[i]);
wasSuccessful = wasSuccessful && runner.run(test);
}
}
return wasSuccessful ? 0 : 1;
}