Ticket #9223: anyvalueset.cpp

#include <gtest/gtest.h>

#include <string>

#include <netrush/system/view/anyvalueset.hpp>

using namespace netrush::view;

struct Foo
{
        int k;
        float l;
};

bool operator==( const Foo& a, const Foo& b )
{
        return a.k == b.k
                && a.l == b.l
                ;
}

bool operator< ( const Foo& a, const Foo& b )
{
        return a.k < b.k
                && a.l < a.l
                ;
}

struct Id
{
        int value;
};

bool operator==( const Id& a, const Id& b )
{
        return a.value == b.value;
}

bool operator< ( const Id& a, const Id& b )
{
        return a.value < b.value;
}


struct Entity
{
        Id id;
        std::string name;
};

bool operator==( const Entity& a, const Entity& b )
{
        return a.id == b.id;
}

bool operator< ( const Entity& a, const Entity& b )
{
        return a.id < b.id;
}

bool operator==( const Id& a, const Entity& b )
{
        return a == b.id;
}
bool operator==( const Entity& a, const Id& b )
{
        return b == a;
}

template< class T >
void test_all_operations( AnyValueSet& value_set, T value )
{
        const auto begin_size = value_set.size();
        value_set.add( value );
        ASSERT_TRUE( value_set.contains( value ) );
        const auto stored_value = value_set.find( value );
        ASSERT_EQ( value, *stored_value );
        ASSERT_EQ( begin_size + 1, value_set.size() );

        auto values = value_set.all<T>();
        auto find_it = std::find( begin( values ), end( values ), value );
        ASSERT_NE( end( values ), find_it );
}

TEST( Test_AnyValueSet, any_kind_of_values )
{
        AnyValueSet value_set;
        test_all_operations( value_set, 42 );
        test_all_operations( value_set, 3.14 );
        test_all_operations( value_set, 0.5f );
        test_all_operations( value_set, Foo{ 42, 0.5f } );
        test_all_operations( value_set, Id{ 1234 } );
        test_all_operations( value_set, Entity{ Id{ 5678 }, "A" } );
}

TEST( Test_AnyValueSet, unique_simple_values )
{
        AnyValueSet value_set;
        value_set.add( 42 );
        value_set.add( 42 );
        value_set.add( 42 );
        value_set.add( 42 );
        value_set.add( 42 );
        ASSERT_EQ( 1, value_set.size() );

}

TEST( Test_AnyValueSet, unique_key_values )
{
        AnyValueSet value_set;
        value_set.add( Entity{ Id{ 42 }, "A" } );
        value_set.add( Entity{ Id{ 42 }, "B" } );
        value_set.add( Entity{ Id{ 42 }, "C" } );
        value_set.add( Entity{ Id{ 42 }, "D" } );
        value_set.add( Entity{ Id{ 42 }, "E" } );

        ASSERT_EQ( 1, value_set.size() );
        ASSERT_EQ( "E", value_set.find<Entity>( Id{ 42 } )->name );
}


TEST( Test_AnyValueSet, merge_sets_same_type )
{
        AnyValueSet set_a, set_b;

        set_a.add( 1 );
        set_a.add( 2 );
        set_a.add( 3 );
        set_a.add( 4 );

        set_b.add( 1 );
        set_b.add( 2 );
        set_b.add( 3 );
        set_b.add( 4 );
        set_b.add( 5 );
        set_b.add( 6 );
        set_b.add( 7 );
        set_b.add( 8 );

        set_a.insert( set_b );
        ASSERT_EQ( set_a.size(), set_b.size() );
        auto b_values = set_b.all<int>();
        for( const auto i : b_values )
        {
                ASSERT_TRUE( set_a.contains( i ) );
        }

        AnyValueSet set_c;
        set_c.insert( set_a );
        auto c_values = set_c.all<int>();
        for( const auto i : c_values )
        {
                ASSERT_TRUE( set_a.contains( i ) );
        }
        for( const auto i : b_values )
        {
                ASSERT_TRUE( set_c.contains( i ) );
        }

}

TEST( Test_AnyValueSet, merge_sets_different_types )
{
        AnyValueSet set_a, set_b;

        set_a.add( 1 );
        set_a.add( 2 );
        set_a.add( 3 );
        set_a.add( 4 );

        set_b.add( 1.f );
        set_b.add( 2.f );
        set_b.add( 3.f );
        set_b.add( 4.f );
        set_b.add( 5.f );
        set_b.add( 6.f );
        set_b.add( 7.f );
        set_b.add( 8.f );

        set_a.insert( set_b );
        AnyValueSet set_c;
        set_c.insert( set_a );

        {

                auto b_values = set_b.all<int>();
                for( const auto i : b_values )
                {
                        ASSERT_TRUE( set_a.contains( i ) );
                }
                auto c_values = set_c.all<int>();
                for( const auto i : c_values )
                {
                        ASSERT_TRUE( set_a.contains( i ) );
                }
                for( const auto i : b_values )
                {
                        ASSERT_TRUE( set_c.contains( i ) );
                }
        }
        {

                auto b_values = set_b.all<float>();
                for( const auto i : b_values )
                {
                        ASSERT_TRUE( set_a.contains( i ) );
                }
                auto c_values = set_c.all<float>();
                for( const auto i : c_values )
                {
                        ASSERT_TRUE( set_a.contains( i ) );
                }
                for( const auto i : b_values )
                {
                        ASSERT_TRUE( set_c.contains( i ) );
                }
        }


}