unordered_tuple.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2017 by J.M.McGuiness, coder@hussar.me.uk
**
** 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "stdafx.h"
 
#define BOOST_TEST_MODULE libjmmcg_tests
#include <boost/test/included/unit_test.hpp>
 
#include "core/unordered_tuple.hpp"
 
using namespace libjmmcg;
 
struct base {
   using key_type=std::int32_t;
 
   struct hasher {
      constexpr key_type operator()(key_type k) const noexcept(true) {
         return k;
      }
      constexpr key_type operator()(key_type k, std::size_t) const noexcept(true) {
         return k;
      }
   };
 
   virtual int fn(int j) const=0;
 
protected:
   virtual ~base()=default;
};
struct int1 final : base {
   static inline constexpr base::key_type hash=1;
 
   const int i_;
 
   explicit int1(int i)
   : i_(i) {}
 
   int fn(int j) const override {
      return i_*j;
   }
};
struct int2 final : base {
   static inline constexpr base::key_type hash=2;
 
   const int i_;
 
   explicit int2(int i)
   : i_(i) {}
 
   int fn(int j) const override {
      return i_+j;
   }
};
struct double1 final : base {
   static inline constexpr base::key_type hash=3;
 
   const double i_;
 
   explicit double1(double i)
   : i_(i) {}
 
   int fn(int j) const override {
      return static_cast<int>(i_+j);
   }
};
 
template<class T>
struct extract {
   static constexpr const typename T::key_type value=T::hash;
};
 
BOOST_AUTO_TEST_SUITE(unordered_tuple_tests)
 
BOOST_AUTO_TEST_CASE(ctor) {
   using collection_type=unordered_tuple<base::key_type, base, base::hasher, extract, int1, int2, double1>;
 
   BOOST_CHECK_NO_THROW(collection_type colln(int1(667), int2(42), double1(68.999999)));
}
 
BOOST_AUTO_TEST_CASE(access_in_order) {
   using collection_type=unordered_tuple<base::key_type, base, base::hasher, extract, int1, int2, double1>;
 
   collection_type colln(int1(667), int2(42), double1(68.999999));
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
}
 
BOOST_AUTO_TEST_CASE(access_reverse_order) {
   using collection_type=unordered_tuple<base::key_type, base, base::hasher, extract, int1, int2, double1>;
 
   collection_type colln(int1(667), int2(42), double1(68.999999));
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
}
 
BOOST_AUTO_TEST_CASE(access_in_then_reverse_order) {
   using collection_type=unordered_tuple<base::key_type, base, base::hasher, extract, int1, int2, double1>;
 
   collection_type colln(int1(667), int2(42), double1(68.999999));
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
}
 
BOOST_AUTO_TEST_CASE(access_reverse_then_in_order) {
   using collection_type=unordered_tuple<base::key_type, base, base::hasher, extract, int1, int2, double1>;
 
   collection_type colln(int1(667), int2(42), double1(68.999999));
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
   BOOST_CHECK_EQUAL(colln[int1::hash].fn(1), 667);
   BOOST_CHECK_EQUAL(colln[int2::hash].fn(13), 55);
   BOOST_CHECK_EQUAL(colln[double1::hash].fn(7), 75);
}
 
BOOST_AUTO_TEST_SUITE_END()