#include <cstring>
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>
#include "cryptonote_basic/cryptonote_basic.h"
#include "cryptonote_basic/cryptonote_basic_impl.h"
#include "ringct/rctSigs.h"
#include "serialization/binary_archive.h"
#include "serialization/json_archive.h"
#include "serialization/debug_archive.h"
#include "serialization/variant.h"
#include "serialization/vector.h"
#include "serialization/binary_utils.h"
#include "wallet/wallet2.h"
#include "gtest/gtest.h"
#include "unit_tests_utils.h"
#include "device/device.hpp"

Include dependency graph for serialization.cpp:

Classes
struct	Struct
struct	serializer< Archive, Struct >
struct	Struct1
struct	Blob
struct	unsigned_tx_set

Macros
#define	OUTPUT_EXPORT_FILE_MAGIC "Electroneum output export\003"
#define	UNSIGNED_TX_PREFIX "Electroneum unsigned tx set\003"
#define	SIGNED_TX_PREFIX "Electroneum signed tx set\003"

Functions
	VARIANT_TAG (binary_archive, Struct, 0xe0)
	VARIANT_TAG (binary_archive, int, 0xe1)
	VARIANT_TAG (json_archive, Struct, "struct")
	VARIANT_TAG (json_archive, int, "int")
	VARIANT_TAG (debug_archive, Struct1, "struct1")
	VARIANT_TAG (debug_archive, Struct, "struct")
	VARIANT_TAG (debug_archive, int, "int")
	BLOB_SERIALIZER (Blob)
bool	try_parse (const string &blob)
	TEST (Serialization, BinaryArchiveInts)
	TEST (Serialization, BinaryArchiveVarInts)
	TEST (Serialization, Test1)
	TEST (Serialization, Overflow)
	TEST (Serialization, serializes_vector_uint64_as_varint)
	TEST (Serialization, serializes_vector_int64_as_fixed_int)
	TEST (Serialization, serializes_transacion_signatures_correctly)
	TEST (Serialization, serializes_ringct_types)
	TEST (Serialization, portability_wallet)
	TEST (Serialization, portability_outputs)
template<class Archive>
void	serialize (Archive &a, unsigned_tx_set &x, const boost::serialization::version_type ver)
	TEST (Serialization, portability_unsigned_tx)
	TEST (Serialization, portability_signed_tx)
	TEST (Serialization, difficulty_type)

Macro Definition Documentation

◆ OUTPUT_EXPORT_FILE_MAGIC

#define OUTPUT_EXPORT_FILE_MAGIC "Electroneum output export\003"

Definition at line 750 of file serialization.cpp.

◆ SIGNED_TX_PREFIX

#define SIGNED_TX_PREFIX "Electroneum signed tx set\003"

Definition at line 1026 of file serialization.cpp.

◆ UNSIGNED_TX_PREFIX

#define UNSIGNED_TX_PREFIX "Electroneum unsigned tx set\003"

Definition at line 877 of file serialization.cpp.

Function Documentation

◆ BLOB_SERIALIZER()

BLOB_SERIALIZER ( Blob )

◆ serialize()

template<class Archive>

void serialize	(	Archive &	a,
		unsigned_tx_set &	x,
		const boost::serialization::version_type	ver )

inline

Definition at line 872 of file serialization.cpp.

{
  a & x.txes;
  a & x.transfers;
}

◆ TEST() [1/13]

TEST	(	Serialization	,
		BinaryArchiveInts	)

Definition at line 126 of file serialization.cpp.

                                       {
  uint64_t x = 0xff00000000, x1;
 
  ostringstream oss;
  binary_archive<true> oar(oss);
  oar.serialize_int(x);
  ASSERT_TRUE(oss.good());
  ASSERT_EQ(8, oss.str().size());
  ASSERT_EQ(string("\0\0\0\0\xff\0\0\0", 8), oss.str());
 
  istringstream iss(oss.str());
  binary_archive<false> iar(iss);
  iar.serialize_int(x1);
  ASSERT_EQ(8, iss.tellg());
  ASSERT_TRUE(iss.good());
 
  ASSERT_EQ(x, x1);
}

◆ TEST() [2/13]

TEST	(	Serialization	,
		BinaryArchiveVarInts	)

Definition at line 145 of file serialization.cpp.

                                          {
  uint64_t x = 0xff00000000, x1;
 
  ostringstream oss;
  binary_archive<true> oar(oss);
  oar.serialize_varint(x);
  ASSERT_TRUE(oss.good());
  ASSERT_EQ(6, oss.str().size());
  ASSERT_EQ(string("\x80\x80\x80\x80\xF0\x1F", 6), oss.str());
 
  istringstream iss(oss.str());
  binary_archive<false> iar(iss);
  iar.serialize_varint(x1);
  ASSERT_TRUE(iss.good());
  ASSERT_EQ(x, x1);
}

◆ TEST() [3/13]

TEST	(	Serialization	,
		difficulty_type	)

Definition at line 1148 of file serialization.cpp.

{
  std::vector<cryptonote::difficulty_type> v_original;
 
  for(int i = 0; i != 100; i++)
  {
    v_original.push_back(cryptonote::difficulty_type("117868131154734361989189100"));
    if(v_original.size() > 1)
      v_original.back() *= v_original[v_original.size()-2];
  }
 
  std::stringstream ss;
  boost::archive::portable_binary_oarchive a(ss);
  a << v_original;
 
  std::vector<cryptonote::difficulty_type> v_unserialized;
 
  boost::archive::portable_binary_iarchive a2(ss);
  a2 >> v_unserialized;
 
  ASSERT_EQ(v_original, v_unserialized);
}