CompositeTest.cpp File Reference

#include <catch2/catch.hpp>
#include "Composite.h"
#include "Callable.h"
#include <algorithm>
#include <array>
#include <functional>
#include <iterator>
#include <numeric>

Include dependency graph for CompositeTest.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{CompositeTest.cpp}::Ignore
struct	anonymous_namespace{CompositeTest.cpp}::MyComponent
struct	anonymous_namespace{CompositeTest.cpp}::MyComponentEx
struct	Composite::Traits< MyCompositeBase, MyBuilder >
struct	Composite::Traits< MyCompositeBase, MyBuilder >::ItemBuilderType
struct	anonymous_namespace{CompositeTest.cpp}::MyBuilder

Namespaces
namespace	anonymous_namespace{CompositeTest.cpp}

Typedefs
using	anonymous_namespace{CompositeTest.cpp}::MyCompositeBase = Base< MyComponent, unique_ptr< MyComponent >, int >
using	anonymous_namespace{CompositeTest.cpp}::MyCompositeBase2 = Base< MyComponent, unique_ptr< MyComponent >, int, Ignore >

Functions
bool	anonymous_namespace{CompositeTest.cpp}::operator== (int n, const unique_ptr< MyComponent > &p)
template<bool members = true, typename Container1 , typename Container2 >
bool	anonymous_namespace{CompositeTest.cpp}::compareSequences (const Container1 &c1, const Container2 &c2)
template<typename Container , auto Maker = nullptr, typename... Args>
void	DoTest (Args ...args)
	TEST_CASE ("Composite::Base")
bool	anonymous_namespace{CompositeTest.cpp}::operator== (int n, const std::unique_ptr< MyComponentEx > &p)
static auto	anonymous_namespace{CompositeTest.cpp}::Maker (int value)
	TEST_CASE ("Composite::Builder")
	TEST_CASE ("Composite::Extension")
	TEST_CASE ("Composite::Extension specialized for void")

Variables
constexpr auto	anonymous_namespace{CompositeTest.cpp}::Component = Callable::UniqueMaker<MyComponent, int>()

Function Documentation

DoTest()

template<typename Container , auto Maker = nullptr, typename... Args>

void DoTest

(

Args ...

args

)

Definition at line 75 of file CompositeTest.cpp.

{
   auto Make = [](int value){
      if constexpr (!bool(Maker))
         return Component(value, Ignore{});
      else
         return Maker(value);
   };
 
   using ComponentType = decltype(Make(0));
   
   // CompositeBase passes constructor arguments to its Component
   Container container{ args... };
   REQUIRE(0 == container);
   REQUIRE(container.empty());
 
   constexpr int N = 4;
 
   // Values for comparison
   vector<int> values(N);
   iota(values.begin(), values.end(), 1);
 
   // Make some components
   vector<ComponentType> components;
   // Not yet equal
   REQUIRE(!compareSequences(values, components));
 
   for (size_t ii = 1; ii <= N; ++ii)
      components.push_back(Make(ii));
 
   // Equal values so far
   if (!bool(Maker))
      REQUIRE(compareSequences(values, components));
 
   // Composite works with push_back and back_inserter
   move(components.begin(), components.end(), back_inserter(container));
   REQUIRE(!container.empty());
   REQUIRE(compareSequences(values, container));
   
   // Break equality of sequences
   values.push_back(N + 1);
   REQUIRE(!compareSequences(values, container));
 
   // Restore equality (and note, Component can take more arguments)
   container.push_back(Make(N + 1));
   REQUIRE(compareSequences(values, container));
}

References anonymous_namespace{CompositeTest.cpp}::compareSequences(), anonymous_namespace{CompositeTest.cpp}::Component, anonymous_namespace{CompositeTest.cpp}::Maker(), and values.

Here is the call graph for this function:

TEST_CASE() [1/4]

TEST_CASE

(

"Composite::Base"

)

Definition at line 123 of file CompositeTest.cpp.

{
   DoTest<MyCompositeBase>(0);
   // Also test the extra arguments of MyComponent
   DoTest<MyCompositeBase2>(0, Ignore{});
}

TEST_CASE() [2/4]

TEST_CASE

(

"Composite::Builder"

)

Definition at line 163 of file CompositeTest.cpp.

{
   using namespace placeholders;
   std::array values{ 0, 1, 2, 3, 4 };
 
   DoTest<MyBuilder, Maker>(0);
   // Test compilation of the variadic constructor and the overload of
   // ItemBuilderType::operator ()
   // Remember first 0 is not an element
   MyBuilder builder{ 0, 0, 1, 2, 3, 4 };
 
   REQUIRE(compareSequences(values, builder));
 
   // Forward range
   MyBuilder builder2{ 0, begin(values), end(values) };
   REQUIRE(compareSequences(values, builder2));
 
   // Transform range
   std::array values2{ 1, 2, 3, 4, 5 };
   MyBuilder builder3{ 0, begin(values2), end(values2),
      bind( minus{}, _1, -1 ) };
   REQUIRE(compareSequences(values, builder2));
}

References details::begin(), anonymous_namespace{CompositeTest.cpp}::compareSequences(), details::end(), and values.

Here is the call graph for this function:

TEST_CASE() [3/4]

TEST_CASE

(

"Composite::Extension specialized for void"

)

Definition at line 196 of file CompositeTest.cpp.

{
   using Container = Extension<MyCompositeBase, void, int>;
   DoTest<Container>(0);
   using Container2 = Extension<MyCompositeBase2, void, int, Ignore>;
   DoTest<Container2>(0, Ignore{});
}

TEST_CASE() [4/4]

TEST_CASE

(

"Composite::Extension"

)

Definition at line 187 of file CompositeTest.cpp.

{
   struct X{};
   using Container = Extension<MyCompositeBase, X, int>;
   DoTest<Container>(0, X{});
   using Container2 = Extension<MyCompositeBase2, X, int, Ignore>;
   DoTest<Container2>(0, Ignore{}, X{});
}