epee::tests Namespace Reference

Classes
struct	port_test_struct
struct	port_test_struct_sub
struct	some_pod_struct
struct	test_struct

Functions
bool	operator!= (const port_test_struct_sub &a, const port_test_struct_sub &b)
bool	operator== (const port_test_struct &a, const port_test_struct &b)
void	fill_struct_with_test_values (port_test_struct &s)
bool	test_portable_storages (const std::string &tests_folder)
bool	operator== (const test_struct &a, const test_struct &b)
test_struct	get_test_struct ()
bool	test_storages (const std::string &tests_folder)

Function Documentation

fill_struct_with_test_values()

void epee::tests::fill_struct_with_test_values

(

port_test_struct &

s

)

Definition at line 155 of file portable_storages_test.h.

    {
      s.m_str = "zuzuzuzuzuz";
      s.m_uint64 = 111111111111111;
      s.m_uint32 = 2222222;
      s.m_uint16 = 2222;
      s.m_uint8 = 22;
      s.m_int64 = -111111111111111;
      s.m_int32 = -2222222;
      s.m_int16 = -2222;
      s.m_int8 = -24;
      s.m_double = 0.11111;
      s.m_bool = true;
      s.m_pod.a = 32342342342342;
      s.m_pod.b = -342342;
      s.m_list_of_str.push_back("1112121");
      s.m_list_of_uint64_t.push_back(1111111111);
      s.m_list_of_uint64_t.push_back(2222222222);
      s.m_list_of_uint32_t.push_back(1111111);
      s.m_list_of_uint32_t.push_back(2222222);
      s.m_list_of_uint16_t.push_back(1111);
      s.m_list_of_uint16_t.push_back(2222);
      s.m_list_of_uint8_t.push_back(11);
      s.m_list_of_uint8_t.push_back(22);
 
 
      s.m_list_of_int64_t.push_back(-1111111111);
      s.m_list_of_int64_t.push_back(-222222222);
      s.m_list_of_int32_t.push_back(-1111111);
      s.m_list_of_int32_t.push_back(-2222222);
      s.m_list_of_int16_t.push_back(-1111);
      s.m_list_of_int16_t.push_back(-2222);
      s.m_list_of_int8_t.push_back(-11);
      s.m_list_of_int8_t.push_back(-22);
 
      s.m_list_of_double.push_back(0.11111);
      s.m_list_of_double.push_back(0.22222);
      s.m_list_of_bool.push_back(true);
      s.m_list_of_bool.push_back(false);
 
      s.m_subobj.m_str = "subszzzzzzzz";
      s.m_list_of_self.push_back(s);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_test_struct()

test_struct epee::tests::get_test_struct ( )

inline

Definition at line 76 of file storage_tests.h.

    {
      test_struct t = boost::value_initialized<test_struct>();
      t.m_bool = true;
      t.m_str = "ackamdc'kmecemcececmacmecmcm[aicm[oeicm[oeicm[qaicm[qoe";
      t.m_uint = 233242;
      for(int i = 0; i!=500; i++)
        t.m_list_of_int.push_back(i);
 
      for(int i = 0; i!=500; i++)
        t.m_list_of_str.push_back("ssccd");
 
      for(int i = 0; i!=5; i++)
      {
        t.m_list_of_self.push_back(t);
      }
      return t; 
    }

Here is the caller graph for this function:

operator!=()

bool epee::tests::operator!=	(	const port_test_struct_sub &	a,
		const port_test_struct_sub &	b )

Definition at line 117 of file portable_storages_test.h.

    {
       return b.m_str != a.m_str;
    }

operator==() [1/2]

bool epee::tests::operator==	(	const port_test_struct &	a,
		const port_test_struct &	b )

Definition at line 122 of file portable_storages_test.h.

    {
      if(   b.m_str != a.m_str 
        ||  b.m_uint64 != a.m_uint64
        ||  b.m_uint32 != a.m_uint32
        ||  b.m_uint16 != a.m_uint16
        ||  b.m_uint8 != a.m_uint8
        ||  b.m_int64 != a.m_int64
        ||  b.m_int32 != a.m_int32
        ||  b.m_int16 != a.m_int16
        ||  b.m_int8 != a.m_int8
        ||  b.m_double != a.m_double
        ||  b.m_bool != a.m_bool
        ||  b.m_pod.a != a.m_pod.a 
        ||  b.m_pod.b != a.m_pod.b 
        ||  b.m_list_of_str != a.m_list_of_str
        ||  b.m_list_of_uint64_t != a.m_list_of_uint64_t
        ||  b.m_list_of_uint32_t != a.m_list_of_uint32_t
        ||  b.m_list_of_uint16_t != a.m_list_of_uint16_t
        ||  b.m_list_of_uint8_t != a.m_list_of_uint8_t
        ||  b.m_list_of_int64_t != a.m_list_of_int64_t
        ||  b.m_list_of_int32_t != a.m_list_of_int32_t
        ||  b.m_list_of_int16_t != a.m_list_of_int16_t
        ||  b.m_list_of_int8_t != a.m_list_of_int8_t
        ||  b.m_list_of_double != a.m_list_of_double
        ||  b.m_list_of_bool != a.m_list_of_bool
        ||  b.m_subobj != a.m_subobj
        ||  b.m_list_of_self != a.m_list_of_self
        )
        return false;
      return true;
    }

operator==() [2/2]

bool epee::tests::operator==	(	const test_struct &	a,
		const test_struct &	b )

Definition at line 63 of file storage_tests.h.

    {
      if(   b.m_str != a.m_str 
        ||  b.m_uint != a.m_uint 
        ||  b.m_bool != a.m_bool 
        ||  b.m_list_of_str != a.m_list_of_str 
        ||  b.m_list_of_int != a.m_list_of_int 
        ||  b.m_list_of_self != a.m_list_of_self 
        )
        return false;
      return true;
    }

test_portable_storages()

bool epee::tests::test_portable_storages

(

const std::string &

tests_folder

)

Definition at line 199 of file portable_storages_test.h.

    {
      serialization::portable_storage ps, ps2;
      port_test_struct s1, s2;
      fill_struct_with_test_values(s1);
 
      s1.store(ps);
      std::string binbuf;
      bool r = ps.store_to_binary(binbuf);
 
      ps2.load_from_binary(binbuf);
      s2.load(ps2);
      if(!(s1 == s2))
      {
        LOG_ERROR("Portable storage  test failed!");
        return false;
      }
 
 
      port_test_struct ss1, ss2;
      fill_struct_with_test_values(ss1);
      std::string json_buff = epee::serialization::store_t_to_json(ss1);
      epee::serialization::load_t_from_json(ss2, json_buff);
      if(!(ss1 == ss2))
      {
        LOG_ERROR("Portable storage  test failed!");
        return false;
      }
 
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

test_storages()

bool epee::tests::test_storages

(

const std::string &

tests_folder

)

Definition at line 95 of file storage_tests.h.

    {
      
      epee::serialization::portable_storage  ps;
      auto s = ps.open_section("zzz", nullptr);
      uint64_t i = 0;
      ps.get_value("afdsdf", i, s);
      
      
      LOG_PRINT_L0("Generating test struct...");
      boost::filesystem::path storage_folder = tests_folder;
      storage_folder /= "storages";
 
 
      test_struct t = get_test_struct();
 
      LOG_PRINT_L0("Loading test struct from storage...");
      test_struct t2;
      bool res = epee::StorageNamed::load_struct_from_storage_file(t2, (storage_folder /+ "valid_storage.bin").string());
      CHECK_AND_ASSERT_MES(res, false, "Failed to load valid_storage.bin");
 
      LOG_PRINT_L0("Comparing generated and loaded test struct...");
      if(!(t == t2))
        return false;
 
      LOG_PRINT_L0("Loading broken archive 1...");
      test_struct t3;
      res = epee::StorageNamed::load_struct_from_storage_file(t3, (storage_folder /+ "invalid_storage_1.bin").string());
      CHECK_AND_ASSERT_MES(!res, false, "invalid_storage_1.bin loaded, but should not ");
 
 
      LOG_PRINT_L0("Loading broken archive 2...");
      res = epee::StorageNamed::load_struct_from_storage_file(t3, (storage_folder /+ "invalid_storage_2.bin").string());
      CHECK_AND_ASSERT_MES(!res, false, "invalid_storage_2.bin loaded, but should not ");
 
      LOG_PRINT_L0("Loading broken archive 3...");
      res = epee::StorageNamed::load_struct_from_storage_file(t3, (storage_folder /+ "invalid_storage_3.bin").string());
      CHECK_AND_ASSERT_MES(!res, false, "invalid_storage_3.bin loaded, but should not ");
 
      LOG_PRINT_L0("Loading broken archive 4...");
      res = epee::StorageNamed::load_struct_from_storage_file(t3, (storage_folder /+ "invalid_storage_4.bin").string());
      CHECK_AND_ASSERT_MES(!res, false, "invalid_storage_3.bin loaded, but should not ");
 
      return true;
    }

Here is the call graph for this function: