// -*- mode: c++; c-basic-offset:4 -*-

// This file is part of libdap, A C++ implementation of the OPeNDAP Data

// Access Protocol.

// Copyright (c) 2002,2003 OPeNDAP, Inc.

// Author: James Gallagher <jgallagher@opendap.org>

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.

#include "config.h"

#include <cppunit/TextTestRunner.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <cppunit/extensions/HelperMacros.h>

#include <cstring>

#include <string>

#include <sstream>

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#include "GNURegex.h"

#include "AttrTable.h"

#include "debug.h"

#include "testFile.h"

#include "GetOpt.h"

static bool debug = false;

#undef DBG

#define DBG(x) do { if (debug) (x); } while(false);

using namespace CppUnit;

using namespace std;

using namespace libdap;

static string build_fqn(AttrTable *at, string fqn)

{

    // The strange behavior at the top level is because the top level of an

    // AttrTable (i.e. the DAS) is anonymous. Another bad design... jhrg 2/8/06

    if (!at || !at->get_parent() || at->get_name().empty())

        return fqn;

    else

        return build_fqn(at->get_parent(), at->get_name() + string(".") + fqn);

}

namespace libdap {

class AttrTableTest: public TestFixture {

private:

    AttrTable *at1;

    AttrTable *cont_a, *cont_b, *cont_c, *cont_ba, *cont_ca, *cont_caa;

public:

    AttrTableTest()

    {

    }

    ~AttrTableTest()

    {

    }

    void setUp()

    {

        at1 = new AttrTable;

        cont_a = at1->append_container("a");

        cont_a->append_attr("size", "Int32", "7");

        cont_a->append_attr("type", "String", "cars");

        cont_b = at1->append_container("b");

        cont_b->append_attr("number", "Int32", "1");

        cont_b->append_attr("type", "String", "houses");

        cont_ba = cont_b->append_container("ba");

        cont_ba->append_attr("name", "String", "fred");

        cont_c = at1->append_container("c");

        cont_ca = cont_c->append_container("ca");

        cont_caa = cont_ca->append_container("caa");

        cont_caa->append_attr("color", "String", "red");

        // This AttrTable looks like:

        //      Attributes {

        //          a {

        //              Int32 size 7;

        //              String type cars;

        //          }

        //          b {

        //              Int32 number 1;

        //              String type houses;

        //              ba {

        //                  String name fred;

        //              }

        //          }

        //          c {

        //              ca {

        //                  caa {

        //                      String color red;

        //                  }

        //              }

        //          }

        //      }

    }

    void tearDown()

    {

        delete at1;

        at1 = 0;

    }

    bool re_match(Regex &r, const char *s)

    {

        return r.match(s, strlen(s)) == (int) strlen(s);

    }

    CPPUNIT_TEST_SUITE (AttrTableTest);

#if 1

    CPPUNIT_TEST (clone_test);

    CPPUNIT_TEST (find_container_test);

    CPPUNIT_TEST (get_parent_test);

    CPPUNIT_TEST (recurrsive_find_test);

    CPPUNIT_TEST (find_test);

    CPPUNIT_TEST (copy_ctor);

    CPPUNIT_TEST (assignment);

    CPPUNIT_TEST (erase_test);

    CPPUNIT_TEST (names_with_spaces_test);

#endif

    CPPUNIT_TEST (containers_with_spaces_test);

#if 1

    CPPUNIT_TEST (get_attr_iter_test);

    CPPUNIT_TEST (del_attr_table_test);

    CPPUNIT_TEST (append_attr_vector_test);

#endif

#if 0

    CPPUNIT_TEST(print_xml_test);

#endif

    CPPUNIT_TEST_SUITE_END();

    // Tests for methods

    // This is to test for leaks in the clone() method.

    void clone_test()

    {

        AttrTable *att = new AttrTable;

        att->append_container(new AttrTable(*cont_a), "copy_of_a");

        delete att;

    }

    void recurrsive_find_test()

    {

        AttrTable::Attr_iter location;

        AttrTable *a = at1->recurrsive_find("color", &location);

        CPPUNIT_ASSERT(a && a == cont_caa && a->get_name(location) == "color");

        a = cont_caa->recurrsive_find("color", &location);

        CPPUNIT_ASSERT(a && a == cont_caa && a->get_name(location) == "color");

        a = at1->recurrsive_find("ba", &location);

        CPPUNIT_ASSERT(a && a == cont_b && a->get_name(location) == "ba");

    }

    void get_parent_test()

    {

        CPPUNIT_ASSERT(cont_caa->get_parent() == cont_ca);

        CPPUNIT_ASSERT(cont_ca->get_parent() == cont_c);

        CPPUNIT_ASSERT(cont_c->get_parent() == at1);

        CPPUNIT_ASSERT(at1->get_parent() == 0);

        CPPUNIT_ASSERT(build_fqn(cont_caa, "color") == "c.ca.caa.color");

    }

    void find_container_test()

    {

        AttrTable *tmp = at1->find_container("a");

        CPPUNIT_ASSERT(tmp != 0);

        CPPUNIT_ASSERT(tmp == cont_a);

        CPPUNIT_ASSERT(at1->find_container("b.ba") == cont_ba);

        CPPUNIT_ASSERT(at1->find_container("a.b") == 0);

        CPPUNIT_ASSERT(at1->find_container("c.ca.caa") == cont_caa);

        CPPUNIT_ASSERT(at1->find_container("caa") == 0);

        CPPUNIT_ASSERT(at1->find_container("a.size") == 0);

        CPPUNIT_ASSERT(at1->find_container("b.ba.name") == 0);

    }

    void find_test()

    {

        AttrTable *tmp;

        AttrTable::Attr_iter iter;

        at1->find("a", &tmp, &iter);

        CPPUNIT_ASSERT(tmp && iter != tmp->attr_end() && tmp->is_container(iter) && tmp->get_name(iter) == "a");

        at1->find("a.size", &tmp, &iter);

        CPPUNIT_ASSERT(

            tmp && iter != tmp->attr_end() && !tmp->is_container(iter) && tmp->get_name(iter) == "size"

                && tmp->get_attr(iter) == "7");

        at1->find("b.type", &tmp, &iter);

        CPPUNIT_ASSERT(

            tmp && iter != tmp->attr_end() && !tmp->is_container(iter) && tmp->get_name(iter) == "type"

                && tmp->get_attr(iter) == "houses");

        at1->find("c.ca.caa.color", &tmp, &iter);

        CPPUNIT_ASSERT(

            tmp && iter != tmp->attr_end() && !tmp->is_container(iter) && tmp->get_name(iter) == "color"

                && tmp->get_attr(iter) == "red");

        at1->find("d.size", &tmp, &iter);

        CPPUNIT_ASSERT(!tmp);

        at1->find("c.size", &tmp, &iter);

        CPPUNIT_ASSERT(tmp == cont_c && iter == tmp->attr_end());

    }

    void copy_ctor()

    {

        AttrTable at2 = *at1;

        AttrTable::Attr_iter piter = at2.attr_begin();

        CPPUNIT_ASSERT(at2.get_name(piter) == "a");

        CPPUNIT_ASSERT(at2.is_container(piter));

        AttrTable *tmp = at2.get_attr_table(piter);

        AttrTable::Attr_iter qiter = tmp->attr_begin();

        CPPUNIT_ASSERT(tmp->get_name(qiter) == "size");

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "b");

        CPPUNIT_ASSERT(at2.is_container(piter));

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "c");

        CPPUNIT_ASSERT(at2.is_container(piter));

    }

    void assignment()

    {

        AttrTable at2;

        at2 = *at1;

        AttrTable::Attr_iter piter = at2.attr_begin();

        CPPUNIT_ASSERT(at2.get_name(piter) == "a");

        CPPUNIT_ASSERT(at2.is_container(piter));

        AttrTable *tmp = at2.get_attr_table(piter);

        AttrTable::Attr_iter qiter = tmp->attr_begin();

        CPPUNIT_ASSERT(tmp->get_name(qiter) == "size");

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "b");

        CPPUNIT_ASSERT(at2.is_container(piter));

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "c");

        CPPUNIT_ASSERT(at2.is_container(piter));

    }

    void erase_test()

    {

        // Copy at1 to at2 and verify that at2 is full of stuff...

        AttrTable at2 = *at1;

        AttrTable::Attr_iter piter = at2.attr_begin();

        CPPUNIT_ASSERT(at2.get_name(piter) == "a");

        CPPUNIT_ASSERT(at2.is_container(piter));

        AttrTable *tmp = at2.get_attr_table(piter);

        AttrTable::Attr_iter qiter = tmp->attr_begin();

        CPPUNIT_ASSERT(tmp->get_name(qiter) == "size");

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "b");

        CPPUNIT_ASSERT(at2.is_container(piter));

        piter++;

        CPPUNIT_ASSERT(at2.get_name(piter) == "c");

        CPPUNIT_ASSERT(at2.is_container(piter));

        at2.erase();

        CPPUNIT_ASSERT(at2.attr_map.size() == 0);

        CPPUNIT_ASSERT(at2.d_name == "");

    }

    void names_with_spaces_test()

    {

        // Create an AttrTable where some names have spaces. The spaces

        // should be replaced by %20 escapes.

        // Replacing the spaces with %20 was the bad, old, behavior. Now

        // the spaces can stay. If someone is writing a DAS using the {}

        // notation, they can use '%20' for the spaces. In the printed

        // DAS using the {} notation, spaces will be represented by %20.

        AttrTable *t = new AttrTable;

        t->append_attr("long name", "String", "first");

        t->append_attr("longer name", "String", "\"second test\"");

        //string sof;

        ostringstream oss;

        t->print(oss, "");

        //FILE2string(sof, of, t->print(of, ""));

        string attrs = "String long%20name \"first\";\n\

String longer%20name \"second test\";";

        //CPPUNIT_ASSERT(sof.find(attrs) != string::npos);

        CPPUNIT_ASSERT(oss.str().find(attrs) != string::npos);

        delete t;

        t = 0;

    }

    void containers_with_spaces_test()

    {

        AttrTable *top = new AttrTable;

        try {

            AttrTable *cont = top->append_container("Data Field");

            cont->append_attr("long name", "String", "first");

            cont->add_value_alias(top, "an alias", "long name");

        }

        catch (Error &e) {

            cerr << e.get_error_message() << endl;

            CPPUNIT_ASSERT("Caught Error exception!" && false);

        }

        try {

            ostringstream oss;

            top->print(oss);

            Regex r(

                ".*Data%20Field \\{\n\

.*String long%20name \"first\";\n\

.*Alias an%20alias long%20name;\n\

.*\\}\n");

            DBG(cout << ">" << oss.str() << "<" << endl);

            CPPUNIT_ASSERT(re_match(r, oss.str().c_str()));

            delete top;

            top = 0;

        }

        catch (Error &e) {

            cerr << e.get_error_message() << endl;

            CPPUNIT_ASSERT("Caught Error exception!" && false);

        }

    }

    void get_attr_iter_test()

    {

        int n = at1->get_size();

        CPPUNIT_ASSERT(n == 3);

        AttrTable::Attr_iter i = at1->get_attr_iter(0);

        CPPUNIT_ASSERT(at1->get_name(i) == "a");

        i = at1->get_attr_iter(2);

        CPPUNIT_ASSERT(at1->get_name(i) == "c");

        i = at1->get_attr_iter(1);

        CPPUNIT_ASSERT(at1->is_container(i));

        AttrTable *t1 = at1->get_attr_table(i);

        AttrTable::Attr_iter k = t1->get_attr_iter(1);

        CPPUNIT_ASSERT(t1->get_name(k) == "type");

        CPPUNIT_ASSERT(t1->get_attr(k, 0) == "houses");

    }

    void del_attr_table_test()

    {

        AttrTable *b = at1->find_container("b");

        AttrTable::Attr_iter i = b->attr_begin();

        CPPUNIT_ASSERT(b->get_name(i) == "number");

        i += 2;

        CPPUNIT_ASSERT(b->get_name(i) == "ba");

        b->del_attr_table(i);

        i = b->attr_begin();

        CPPUNIT_ASSERT(b->get_name(i) == "number");

        i += 2;

        CPPUNIT_ASSERT(i == b->attr_end());

        // try a second table. at2 contains a scalar attribute followed by a

        // container named 'a'.

        AttrTable *at2;

        try {

            at2 = new AttrTable;

            at2->set_name("at2");

            at2->append_attr("color", "String", "red");

            AttrTable *cont_at2 = at2->append_container("cont_at2");

            cont_at2->append_attr("size", "Int32", "7");

            cont_at2->append_attr("type", "String", "cars");

            i = at2->attr_begin();

            CPPUNIT_ASSERT(at2->get_name(i) == "color");

            i++;

            CPPUNIT_ASSERT(at2->get_name(i) == "cont_at2");

            at2->del_attr_table(i);

            i = at2->attr_begin();

            CPPUNIT_ASSERT(at2->get_name(i) == "color");

            i++;

            CPPUNIT_ASSERT(i == at2->attr_end());

            delete at2;

            at2 = 0;

        }

        catch (Error &e) {

            cerr << "Error: " << e.get_error_message() << endl;

            delete at2;

            at2 = 0;

            throw;

        }

        catch (...) {

            cerr << "caught an exception!" << endl;

            delete at2;

            at2 = 0;

            throw;

        }

    }

    void append_attr_vector_test()

    {

        // ("size", "Int32", "7")

        vector<string> vs;

        vs.push_back("8");

        vs.push_back("9");

        cont_a->append_attr("size", "Int32", &vs);

        CPPUNIT_ASSERT(cont_a->get_attr("size", 0) == "7");

        CPPUNIT_ASSERT(cont_a->get_attr("size", 1) == "8");

        CPPUNIT_ASSERT(cont_a->get_attr("size", 2) == "9");

        CPPUNIT_ASSERT(cont_a->get_attr_num("size") == 3);

    }

    void print_xml_test()

    {

        at1->print_xml(stdout);

    }

};

CPPUNIT_TEST_SUITE_REGISTRATION (AttrTableTest);

} // namespace libdap

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: AttrTableTest has the following tests:" << endl;

            const std::vector<Test*> &tests = libdap::AttrTableTest::suite()->getTests();

            unsigned int prefix_len = libdap::AttrTableTest::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 = libdap::AttrTableTest::suite()->getName().append("::").append(argv[i]);

            wasSuccessful = wasSuccessful && runner.run(test);

        }

    }

    return wasSuccessful ? 0 : 1;

}