ReferenceTypeListTest.cpp File Reference

#include "Core/Structures/LinkedList/ReferenceList/Reference.hpp"
#include "Core/Structures/LinkedList/ReferenceList/RefManager.hpp"
#include "Core/Structures/TypeList.hpp"
#include <boost/test/unit_test.hpp>
#include <cstring>
#include <iostream>
#include <cassert>

Include dependency graph for ReferenceTypeListTest.cpp:

Classes
class	TestRefManager< OBJECT >
class	TestReference< OBJECT >
class	ReferenceObject< T >
class	GenericTestObject
class	A
class	B
class	C
struct	ContainerMapList< OBJECT >
struct	ContainerMapList< TypeNull >
struct	ContainerMapList< TypeList< HEAD, TAIL > >
class	TypeRefContainer< OBJECT_TYPES >
class	TypeContainerVisitor< VISITOR, TYPE_CONTAINER >
class	CompareGenericTestObjectID
struct	GenericTestObjectSearcher< PREDICATE >

Namespaces
namespace	TypeListIterator

Macros
#define	BOOST_TEST_MODULE   "ReferenceTypeListTest"
#define	MAX_A_TYPES   3
#define	MAX_B_TYPES   6
#define	MAX_C_TYPES   9
#define	ID_CHECK   42

Functions
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	TypeListIterator::Insert (ContainerMapList< SPECIFIC_TYPE > &elements, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	TypeListIterator::Insert (ContainerMapList< TypeNull > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
SPECIFIC_TYPE *	TypeListIterator::Insert (ContainerMapList< T > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class HEAD , class TAIL >
SPECIFIC_TYPE *	TypeListIterator::Insert (ContainerMapList< TypeList< HEAD, TAIL > > &elements, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE >
size_t	TypeListIterator::count (ContainerMapList< SPECIFIC_TYPE > const &elements, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE >
size_t	TypeListIterator::count (ContainerMapList< TypeNull > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	TypeListIterator::count (ContainerMapList< T > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	TypeListIterator::count (ContainerMapList< TypeList< SPECIFIC_TYPE, T > > const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE , class H , class T >
size_t	TypeListIterator::count (ContainerMapList< TypeList< H, T > > const &elements, SPECIFIC_TYPE *fake)
template<class TypeNull >
size_t	TypeListIterator::count_all (ContainerMapList< TypeNull > const &elements)
template<class H , class T >
size_t	TypeListIterator::count_all (ContainerMapList< TypeList< H, T > > const &elements)
template<class VISITOR >
void	VisitorHelper (VISITOR &, ContainerMapList< TypeNull > &)
template<class VISITOR , class T >
void	VisitorHelper (VISITOR &v, ContainerMapList< T > &c)
template<class VISITOR , class H , class T >
void	VisitorHelper (VISITOR &v, ContainerMapList< TypeList< H, T > > &c)
template<class VISITOR , class OBJECT_TYPES >
void	VisitorHelper (VISITOR &v, TypeRefContainer< OBJECT_TYPES > &c)
typedef	TYPELIST_3 (A, B, C) MyTypes
void	print_count (TypeRefContainer< MyTypes > &refContainer)
	BOOST_AUTO_TEST_CASE (ReferenceTypeListTest)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   "ReferenceTypeListTest"

ID_CHECK

#define ID_CHECK   42

MAX_A_TYPES

#define MAX_A_TYPES   3

MAX_B_TYPES

#define MAX_B_TYPES   6

MAX_C_TYPES

#define MAX_C_TYPES   9

Function Documentation

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

ReferenceTypeListTest

)

Searcher & Checker tests.

{
    TypeRefContainer<MyTypes> refContainer;
 
    A *a[MAX_A_TYPES];
    B *b[MAX_B_TYPES];
    C *c[MAX_C_TYPES];
 
    print_count(refContainer);
 
    int aids[] = { 11, 21, 36 };
    for (int i = 0; i < MAX_A_TYPES; i++) {
        a[i] = new A(aids[i]);
        refContainer.template insert<A>(a[i]);
        assert(a[i]->is_valid());
    }
 
    BOOST_CHECK_EQUAL(refContainer.count<A>(), MAX_A_TYPES);
    BOOST_CHECK_EQUAL(refContainer.count<B>(), 0);
    BOOST_CHECK_EQUAL(refContainer.count<C>(), 0);
 
    int bids[6] = { 12, 22, 37, 42, 51, 62 };
    for (int i = 0; i < MAX_B_TYPES; i++) {
        b[i] = new B(bids[i]);
        refContainer.template insert<B>(b[i]);
        assert(b[i]->is_valid());
    }
    BOOST_CHECK_EQUAL(refContainer.count<A>(), MAX_A_TYPES);
    BOOST_CHECK_EQUAL(refContainer.count<B>(), MAX_B_TYPES);
    BOOST_CHECK_EQUAL(refContainer.count<C>(), 0);
 
    int cids[9] = { 13, 23, 38, 43, 52, 63, 71, 87, 99 };
    for (int i = 0; i < MAX_C_TYPES; i++) {
        c[i] = new C(cids[i]);
        refContainer.template insert<C>(c[i]);
        assert(c[i]->is_valid());
    }
 
    BOOST_CHECK_EQUAL(refContainer.count<A>(), MAX_A_TYPES);
    BOOST_CHECK_EQUAL(refContainer.count<B>(), MAX_B_TYPES);
    BOOST_CHECK_EQUAL(refContainer.count<C>(), MAX_C_TYPES);
 
    print_count(refContainer);
 
#define ID_CHECK 42
    GenericTestObject *res = nullptr;
    CompareGenericTestObjectID check(ID_CHECK);
    GenericTestObjectSearcher<CompareGenericTestObjectID> searcher(res, check);
    TypeContainerVisitor<GenericTestObjectSearcher<CompareGenericTestObjectID>, TypeRefContainer<MyTypes>>  id_searcher(searcher);
    id_searcher.Visit(refContainer);
 
    BOOST_CHECK_EQUAL(res->get_id(), ID_CHECK);
 
    //printf("Found res of type %c id %d\n", res->get_type(), res->get_id());
 
    for (int i = 0; i < MAX_A_TYPES; i++) {
        a[i]->remove_reference();
        delete a[i];
    }
    for (int i = 0; i < MAX_B_TYPES; i++) {
        b[i]->remove_reference();
        delete b[i];
    }
    for (int i = 0; i < MAX_C_TYPES; i++) {
        c[i]->remove_reference();
        delete c[i];
    }
#undef ID_CHECK
 
    BOOST_CHECK_EQUAL(refContainer.count<A>(), 0);
    BOOST_CHECK_EQUAL(refContainer.count<B>(), 0);
    BOOST_CHECK_EQUAL(refContainer.count<C>(), 0);
 
    print_count(refContainer);
}

References TypeRefContainer< OBJECT_TYPES >::count(), GenericTestObject::get_id(), ID_CHECK, MAX_A_TYPES, MAX_B_TYPES, MAX_C_TYPES, print_count(), ReferenceObject< T >::remove_reference(), and TypeContainerVisitor< VISITOR, TYPE_CONTAINER >::Visit().

Here is the call graph for this function:

print_count()

void print_count

(

TypeRefContainer< MyTypes > &

refContainer

)

{
    std::cout << "A: " << refContainer.count<A>()
    << " | B: " << refContainer.count<B>()
    << " | C: " << refContainer.count<C>() << std::endl;
 
    std::cout << "Total of " << refContainer.count_all() << " elements created." << std::endl;
}

References TypeRefContainer< OBJECT_TYPES >::count(), and TypeRefContainer< OBJECT_TYPES >::count_all().

Referenced by BOOST_AUTO_TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

TYPELIST_3()

typedef TYPELIST_3	(	A	,
		B	,
		C
	)

VisitorHelper() [1/4]

template<class VISITOR >

void VisitorHelper	(	VISITOR &	,
		ContainerMapList< TypeNull > &
	)

{
    // terminate condition container map list
}

Referenced by TypeContainerVisitor< VISITOR, TYPE_CONTAINER >::Visit(), and VisitorHelper().

Here is the caller graph for this function:

VisitorHelper() [2/4]

template<class VISITOR , class T >

void VisitorHelper	(	VISITOR &	v,
		ContainerMapList< T > &	c
	)

{
    v.Visit(c._element);
}

References ContainerMapList< OBJECT >::_element.

VisitorHelper() [3/4]

template<class VISITOR , class H , class T >

void VisitorHelper	(	VISITOR &	v,
		ContainerMapList< TypeList< H, T > > &	c
	)

{
    VisitorHelper(v, c._elements); // template<class OBJECT> struct ContainerMapList
    VisitorHelper(v, c._tail_elements); // template<class HEAD, class TAIL> struct ContainerMapList<TypeList<HEAD, TAIL>>
}

References VisitorHelper().

Here is the call graph for this function:

VisitorHelper() [4/4]

template<class VISITOR , class OBJECT_TYPES >

void VisitorHelper	(	VISITOR &	v,
		TypeRefContainer< OBJECT_TYPES > &	c
	)

{
    VisitorHelper(v, c.get_elements());
}

References TypeRefContainer< OBJECT_TYPES >::get_elements(), and VisitorHelper().

Here is the call graph for this function: