roundtrip_associative

Source: tests/io/roundtrip.cpp

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

// Serialization backend that just saves to std::vector<char>.
#include <myramath/io/VectorStream.h>

// Test serialization of basic types.
#include <myramath/io/detail/complex.h>
#include <myramath/io/detail/pair.h>
#include <myramath/io/detail/string.h>

// Test serialization of sequence containers.
#include <myramath/io/detail/vector.h>
#include <myramath/io/detail/list.h>
#ifdef MYRAMATH_ENABLE_CPP11
#include <myramath/io/detail/array.h>
#endif

// Test serialization of associative containers.
#include <myramath/io/detail/map.h>
#include <myramath/io/detail/set.h>
#ifdef MYRAMATH_ENABLE_CPP11
#include <myramath/io/detail/unordered_map.h>
#include <myramath/io/detail/unordered_set.h>
#endif

// Reporting.
#include <tests/myratest.h>

using namespace myra;

namespace {

// Write t1, read back into t2 and compare.
template<class T> void test(const T& t1)
  {
  VectorStream inout;
  inout.write(t1);
  T t2 = inout.read<T>();
  bool equivalent = (t1 == t2);
  REQUIRE(equivalent);
  }

}

// Basic pod types.
ADD_TEST("roundtrip_pod","[io]")
  {
  test<size_t>(423876);
  test<int>(26);
  test<char>('x');
  test<float>(0.8f);
  test<double>( std::sqrt(2.0) );
  }

// Simple aggregate types.
ADD_TEST("roundtrip_struct","[io]")
  {
  typedef std::complex<float> C;
  test<C>(C(0.8f,6.2f));
  typedef std::complex<double> Z;
  test<Z>(Z(4.1,2.7));
  typedef std::pair<int,double> P;
  test<P>(P(12,2.9));  
  }

// Sequence containers.
ADD_TEST("roundtrip_sequence","[io]")
  {
  // std::string
  test<std::string> ("hello");
  typedef std::vector<float> V;
  // std::vector
  V v; v.push_back(1.0f); v.push_back(3.14159f); v.push_back(2.71828f);
  test<V> (v);  
  // std::list
  typedef std::list<double> L;
  L l; l.push_back(1.0); l.push_back(4.0); l.push_back(9.0); l.push_back(16.0);
  test<L> (l);  
#ifdef MYRAMATH_ENABLE_CPP11
  // std::array
  typedef std::array<int,3> A;
  test<A>( A({5,2,9}) );
#endif
  }

// Associative containers.
ADD_TEST("roundtrip_associative","[io]")
  {
  // std::set
  typedef std::set< std::string > S;
  S s; s.insert("apple"); s.insert("orange"); s.insert("grape");
  test<S>(s);
  // std::map
  typedef std::map<int,std::string> M;
  M m; m[0] = "zero"; m[1] = "one"; m[3] = "three";
  test<M>(m);
#ifdef MYRAMATH_ENABLE_CPP11
  // std::unordered_set
  typedef std::unordered_set<int> US;
  US us; us.insert(2); us.insert(3); us.insert(5); us.insert(7); us.insert(9);
  test<US>(us);
  // std::unordered_map
  typedef std::unordered_map< std::string, std::string > UM;
  UM um; um["KY"] = "Kentucky"; um["OH"] = "Ohio"; um["IA"] = "Indiana";
  test<UM>(um);
#endif
  }

Results: [PASS]

Go back to Summary of /test programs.