danicoin/tests/unit_tests/serialization_kv.cpp

241 lines
5.5 KiB
C++
Raw Normal View History

// Copyright (c) 2012-2014, The CryptoNote developers, The Bytecoin developers
//
// This file is part of Bytecoin.
//
// Bytecoin 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 3 of the License, or
// (at your option) any later version.
//
// Bytecoin 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 Bytecoin. If not, see <http://www.gnu.org/licenses/>.
#include "gtest/gtest.h"
#include <boost/lexical_cast.hpp>
#include "serialization/KVBinaryInputStreamSerializer.h"
#include "serialization/KVBinaryOutputStreamSerializer.h"
#include "serialization/keyvalue_serialization.h"
#include "serialization/keyvalue_serialization_overloads.h"
#include "storages/portable_storage.h"
#include "storages/portable_storage_from_bin.h"
#include "storages/portable_storage_template_helper.h"
#include <array>
using namespace cryptonote;
namespace cryptonote {
template <typename Cont>
void serializeAsPod(Cont& cont, const std::string& name, ISerializer& s) {
typedef typename Cont::value_type ElementType;
const size_t elementSize = sizeof(ElementType);
std::string buf;
if (s.type() == ISerializer::INPUT) {
s.binary(buf, name);
const ElementType* ptr = reinterpret_cast<const ElementType*>(buf.data());
size_t count = buf.size() / elementSize;
cont.insert(cont.begin(), ptr, ptr + count);
} else {
auto rawSize = cont.size() * elementSize;
auto ptr = reinterpret_cast<const char*>(cont.data());
buf.assign(ptr, ptr + rawSize);
s.binary(buf, name);
}
}
struct TestElement {
std::string name;
uint32_t nonce;
std::array<uint8_t, 16> blob;
std::vector<uint32_t> u32array;
bool operator == (const TestElement& other) const {
return
name == other.name &&
nonce == other.nonce &&
blob == other.blob &&
u32array == other.u32array;
}
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(name)
KV_SERIALIZE(nonce)
KV_SERIALIZE_VAL_POD_AS_BLOB(blob)
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(u32array)
END_KV_SERIALIZE_MAP()
void serialize(ISerializer& s, const std::string& nm) {
s.beginObject(nm);
s(name, "name");
s(nonce, "nonce");
s.binary(blob.data(), blob.size(), "blob");
serializeAsPod(u32array, "u32array", s);
s.endObject();
}
};
struct TestStruct {
uint8_t u8;
uint32_t u32;
uint64_t u64;
std::vector<TestElement> vec1;
std::vector<TestElement> vec2;
TestElement root;
bool operator == (const TestStruct& other) const {
return
root == other.root &&
u8 == other.u8 &&
u32 == other.u32 &&
u64 == other.u64 &&
vec1 == other.vec1 &&
vec2 == other.vec2;
}
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(root)
KV_SERIALIZE(vec1)
KV_SERIALIZE(vec2)
KV_SERIALIZE(u8)
KV_SERIALIZE(u32)
KV_SERIALIZE(u64)
END_KV_SERIALIZE_MAP()
void serialize(ISerializer& s, const std::string& name) {
s.beginObject(name);
s(root, "root");
s(vec1, "vec1");
s(vec2, "vec2");
s(u8, "u8");
s(u32, "u32");
s(u64, "u64");
s.endObject();
}
};
}
#include <chrono>
typedef std::chrono::high_resolution_clock hclock;
class HiResTimer {
public:
HiResTimer() :
start(hclock::now()) {}
std::chrono::duration<double> duration() {
return hclock::now() - start;
}
private:
hclock::time_point start;
};
TEST(KVSerialize, Simple) {
TestElement testData1, testData2;
std::string buf;
testData1.name = "hello";
testData1.nonce = 12345;
testData1.u32array.resize(128);
testData2.name = "bye";
testData2.nonce = 54321;
epee::serialization::store_t_to_binary(testData1, buf);
std::stringstream s(buf);
KVBinaryInputStreamSerializer kvInput(s);
kvInput.parse();
kvInput(testData2, "");
EXPECT_EQ(testData1, testData2);
}
TEST(KVSerialize, NewWriterOldReader) {
std::string bufOld, bufNew;
TestStruct s1;
TestStruct s2;
s1.u64 = 0xffULL << 50;
s1.vec1.resize(37);
s1.root.name = "somename";
s1.root.u32array.resize(128);
s2.u64 = 13;
s2.vec2.resize(10);
{
HiResTimer t;
epee::serialization::store_t_to_binary(s1, bufOld);
std::cout << "Old serialization: " << t.duration().count() << std::endl;
}
{
HiResTimer t;
KVBinaryOutputStreamSerializer kvOut;
kvOut(s1, "");
std::stringstream out;
kvOut.write(out);
bufNew = out.str();
std::cout << "New serialization: " << t.duration().count() << std::endl;
}
{
HiResTimer t;
TestStruct outStruct(s2);
std::stringstream s(bufOld);
KVBinaryInputStreamSerializer kvInput(s);
kvInput.parse();
kvInput(outStruct, "");
std::cout << "New deserialization: " << t.duration().count() << std::endl;
EXPECT_EQ(s1, outStruct);
}
{
HiResTimer t;
TestStruct outStruct(s2);
bool parseOld = epee::serialization::load_t_from_binary(outStruct, bufOld);
ASSERT_TRUE(parseOld);
std::cout << "Old deserialization: " << t.duration().count() << std::endl;
EXPECT_EQ(s1, outStruct);
}
{
TestStruct outStruct(s2);
bool parseNew = epee::serialization::load_t_from_binary(outStruct, bufNew);
ASSERT_TRUE(parseNew);
EXPECT_EQ(s1, outStruct);
}
}