reflect/test/unit_test.cpp

Go to the documentation of this file.

//
// Copyright (c) 2003
// Paul Hamilton; pHamtec P/L
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee, 
// provided that the above copyright notice appears in all copies and 
// that both the copyright notice and this permission notice appear in 
// supporting documentation. No representations are made about the 
// suitability of this software for any purpose. It is provided "as is" 
// without express or implied warranty.
//
// unit_test.cpp
//
// 4-Jul-2003  phamilton  Created
//

#include <iostream>
#include <vector>
#include <string>
#include <boost/test/included/unit_test_framework.hpp>
#include "../object_visitor.hpp"
#include "../jscript_object_navigator.hpp"
#include "../jscript_object_nav_errors.h"
#include "../member_visitor.hpp"
#include "root.hpp"
#include "foo.hpp"
#include "bar.hpp"

using namespace ph::reflect;
using namespace reflect_test;
using boost::unit_test_framework::test_suite;
using boost::test_toolbox::output_test_stream;

static void set(base *obj, const std::string &name, const std::string &val)
{
        set_member_visitor v(name, val);
        obj->accept(&v);
}

static std::string get(base *obj, const std::string &name)
{
        ph::common::get_member_value_visitor v(name);
        obj->accept(&v);
        return v.get();
}

// here are some macros we use to test whether an object with a particular path has the correct name.
// they are macros so that they will display the correct line number.

#define TEST_OBJ_NAME(_obj_, _path_, _name_) \
{ \
        ph::common::object_base *o = nav.navigate(_obj_, _path_); \
        BOOST_CHECK(output.is_empty()); \
        BOOST_REQUIRE_MESSAGE(o, "could not find [" _path_ "]"); \
        std::string name; \
        BOOST_CHECK_MESSAGE(ph::common::get_visitable_obj_name(o, &name), \
                "[" _path_ "] object does not have a name."); \
        BOOST_CHECK_MESSAGE(name == _name_, \
                "[" _path_ "] was named [" + name + "] not [" _name_ "]"); \
}

#define TEST_BAD_PARSE(_obj_, _path_, _msg_, _name_) \
{ \
        BOOST_CHECK(nav.navigate(_obj_, _path_) == 0); \
        BOOST_CHECK_MESSAGE(output.is_equal( \
                "Syntax Error. " _msg_ " [" _name_ "]\n"), "Syntax Error. " _msg_ " [" _name_ "]"); \
}

namespace reflect_test {

class test_simple
{
public:
        void test()
        {
                foo *o = new foo("foo", "foo");
                BOOST_REQUIRE_MESSAGE(o, "could not create foo object.");
                set(o, "x", "1");
                set(o, "y", "2.1");
                set(o, "z", "true");
                BOOST_CHECK(get(o, "x") == "1");
                BOOST_CHECK(get(o, "y") == "2.1");
                BOOST_CHECK(get(o, "z") == "true");
                delete o;
        }
};

class test_composite
{
public:
                        
        void test()
        {
                {
                        // create a root object.
                        root *r = new root("root", "root");
                        
                        // now search for a particular object using the object parser.
                        output_test_stream output;
                        jscript_object_navigator nav(r, &output, false, false);
                        
                        // test adding new members to the composites.
                        ph::common::object_base *p = nav.navigate(r, "root().foos()");
                        BOOST_CHECK(output.is_empty());
                        BOOST_REQUIRE(p);
                        BOOST_REQUIRE_MESSAGE(p->composition(), 
                                "object does not implement composite interface.");
                        ph::common::composite_object_base *c = 
                                p->composition()->composite();
                        BOOST_REQUIRE_MESSAGE(c, "foos was not a composite object.");
                        
                        // create a new foo object.
                        foo *foo_1 = new foo("foo", "foo_1");
                        BOOST_REQUIRE_MESSAGE(foo_1, "could not create foo object.");
                        BOOST_CHECK(c->add(foo_1, true));
        
                        // make sure it's there.
                        TEST_OBJ_NAME(r, "root().foos(1)", "foo_1");
                        
                        // now remove it.
                        BOOST_CHECK(c->remove(foo_1));
                        
                        // make sure it's not there.
                        TEST_BAD_PARSE(r, "root().foos(1)", 
                                "Object with numeric subscript was not found.", "1");
        
                        // test the singleton composite to make sure that errors working.
                        TEST_BAD_PARSE(r, "root().a_foo", "Singleton composite was empty.", "a_foo");
        
                        // now add foo onto the a_foo
                        p = nav.navigate(r, "root().a_foo()");
                        BOOST_CHECK(output.is_empty());
                        BOOST_REQUIRE(p);
                        BOOST_REQUIRE_MESSAGE(p->composition(), 
                                "object does not implement composite interface.");
                        c = p->composition()->composite();
                        BOOST_REQUIRE_MESSAGE(c, "object was not a composite object.");
        
                        BOOST_CHECK(c->add(foo_1, true));
        
                        // make sure it's there.
                        TEST_OBJ_NAME(r, "root().a_foo", "foo_1");
        
                        delete r;
                }
                {
                        // create a root object.
                        root *r = new root("root", "root");
                        
                        // now search for a particular object using the object parser.
                        output_test_stream output;
                        jscript_object_navigator nav(r, &output, false);
                        
                        // now add a bunch of foos and bars to this object.
                        r->addfoosandbars();

                        // test the parent-relationship of composites.
                        ph::common::object_base *bar_2 = nav.navigate(r, "root().bars('bar_2')");
                        BOOST_CHECK(output.is_empty());
                        BOOST_CHECK(bar_2);
                        if (bar_2)
                        {
                                // get bars
                                ph::common::object_base *bars = nav.navigate(r, "root().bars()");
                                BOOST_CHECK(output.is_empty());
                                BOOST_CHECK(bars);
                                if (bars)
                                        test_parents(bar_2, bars, "bars");
                        }
                        
                        // test the parent-relationship of references.
                        ph::common::object_base *foo_3 = nav.navigate(r, "root().a_foo");
                        BOOST_CHECK(output.is_empty());
                        BOOST_CHECK(foo_3);
                        if (foo_3)
                        {
                                // get a_foo
                                ph::common::object_base *a_foo = nav.navigate(r, "root().a_foo()");
                                BOOST_CHECK(output.is_empty());
                                BOOST_CHECK(a_foo);
                                if (a_foo)
                                        test_parents(foo_3, a_foo, "a_foo");
                        }

                        delete r;
                }
        }
        
        void test_parents(ph::common::object_base *obj, 
                        ph::common::object_base *composite, const std::string &parentname)
        /*
                test the parent-relationship of composites.
        */
        {
                // see what the name of the parent of this guy is.
                BOOST_REQUIRE_MESSAGE(obj->outerable(), 
                        "object doesn't implement outer interface.");
                ph::common::object_base *parent = obj->outerable()->outer();
                BOOST_CHECK(parent);
                if (parent)
                {
                        // test comparable interface.
                        BOOST_REQUIRE_MESSAGE(parent->comparable(), 
                                "parent doesn't implement comparable interface");
                        BOOST_CHECK(parent->comparable()->equal(composite));
                        
                        // now walk out and make sure all the parents are correct.
                        std::string name;
                        BOOST_CHECK_MESSAGE(ph::common::get_visitable_obj_name(parent, &name),
                                                "object does not have a name.");
                        BOOST_CHECK(name == parentname);
                        BOOST_REQUIRE_MESSAGE(parent->outerable(), 
                                "parent doesn't implement outer interface.");
                        parent = parent->outerable()->outer();
                        BOOST_CHECK(parent);
                        if (parent)
                        {
                                BOOST_CHECK_MESSAGE(ph::common::get_visitable_obj_name(parent, &name),
                                                "object does not have a name.");
                                BOOST_CHECK(name == "root");
                                BOOST_REQUIRE_MESSAGE(parent->outerable(), 
                                        "parent doesn't implement outer interface.");
                                BOOST_CHECK(parent->outerable()->outer() == 0);
                        }
                }
        }
};

class test_navigation
{
public:

        void test()
        {
                // create a root object.
                root *r = new root("root", "root");
                
                // now add a bunch of foos and bars to this object.
                r->addfoosandbars();
                
                // now search for a particular object using the object parser.
                output_test_stream output;
                jscript_object_navigator nav(r, &output, false, false);
                
                // test root() navigation.
                TEST_OBJ_NAME(r, "root()", "root");
        
                // test sub-object navigation.
                TEST_OBJ_NAME(r, "root().foos('foo_2')", "foo_2");
                TEST_OBJ_NAME(r, "root().foos(1)", "foo_1");
                TEST_OBJ_NAME(r, "root().foos(2)", "foo_2");
                TEST_OBJ_NAME(r, "root().bars('bar_1')", "bar_1");
                TEST_OBJ_NAME(r, "root().bars(1)", "bar_1");
                TEST_OBJ_NAME(r, "root().bars(2)", "bar_2");
        
                // test for invalid composites.
                TEST_BAD_PARSE(r, "root().foos", 
                        "Object was not a singleton composite. Did you mean to use ()?.", "foos");

                // test composite navigation.
                TEST_OBJ_NAME(r, "root().foos()", "foos");
                TEST_OBJ_NAME(r, "root().a_foo()", "a_foo");

                // test for our object reference special case. 
                // The name of the composite actually returns the 
                // object attached.
                TEST_OBJ_NAME(r, "root().a_foo", "foo_3");
                
                // test complicated queries.
                TEST_OBJ_NAME(r, "root().foos('foo_2').parent().bars('bar_1')", "bar_1");
        
                // test for gobbledegook.
                
                // no composites.
                TEST_BAD_PARSE(r, "()", "No builtin or composite found.", "");
                TEST_BAD_PARSE(r, "xxxxx()", "No builtin or composite found.", "xxxxx");
                TEST_BAD_PARSE(r, "root().xxxxx()", "No builtin or composite found.", "xxxxx");
                TEST_BAD_PARSE(r, "root().()", "No builtin or composite found.", "");

                TEST_BAD_PARSE(r, "yyyy(1)", "No composite found.", "yyyy");

                TEST_BAD_PARSE(r, "root().foos(1).parent('xxxx')", "Parent was not found.", "xxxx");
                TEST_BAD_PARSE(r, "root().foos(1).parent(2)", 
                        "Parent with subscript was not found.", "2");

                TEST_BAD_PARSE(r, "root().foos(5)", 
                        "Object with numeric subscript was not found.", "5");

                TEST_BAD_PARSE(r, "root().foos('xxxx')", 
                        "Object with name subscript was not found.", "'xxxx'");

                // couldn't find objects.
                TEST_BAD_PARSE(r, "xxxxx", "No composite found.", "xxxxx");
                TEST_BAD_PARSE(r, "root().xxxxx", "No composite found.", "xxxxx");
                TEST_BAD_PARSE(r, "root().foos('foo_1", "No composite found.", "foos('foo_1");
                TEST_BAD_PARSE(r, "root().foos('foo_1'", "No composite found.", "foos('foo_1'");
                TEST_BAD_PARSE(r, "root().foos('", "No composite found.", "foos('");
                TEST_BAD_PARSE(r, "root().foos(", "No composite found.", "foos(");
                TEST_BAD_PARSE(r, "root(", "No composite found.", "root(");
                
                // couldn't parse.
                TEST_BAD_PARSE(r, "....", "Empty part. Couldn't Parse.", "....");

                delete r;
        }
};

class test_dump
{
public:
        test_dump(const std::string &filename) :
                _filename(filename)
                        {};
                        
        void test()
        {
                // create a root object.
                root *r = new root("root", "root");
                
                // now add a bunch of foos and bars to this object.
                r->addfoosandbars();
                
                {
                        output_test_stream output(_filename, true);
                        {
                                dump_object_visitor v(&output);
                                BOOST_CHECK(r->accept(&v));
                        }
                        BOOST_CHECK(output.match_pattern());
                }
        
                delete r;
        }

private:
        std::string _filename;
};

};

test_suite *init_unit_test_suite(int argc, char* argv[]) 
{
    test_suite * test = BOOST_TEST_SUITE("reflect units tests");
    
        test->add(BOOST_CLASS_TEST_CASE(&test_simple::test, 
                boost::shared_ptr<test_simple>(new test_simple())));
        test->add(BOOST_CLASS_TEST_CASE(&test_composite::test, 
                boost::shared_ptr<test_composite>(new test_composite())));      
        test->add(BOOST_CLASS_TEST_CASE(&test_navigation::test, 
                boost::shared_ptr<test_navigation>(new test_navigation())));
        test->add(BOOST_CLASS_TEST_CASE(&test_dump::test, 
                boost::shared_ptr<test_dump>(new test_dump(argv[1]))));

    return test;
}

---