|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#include "catch.hpp"
#include <utility>
#include <algorithm>
#include <iterator>
#include "FWCore/SharedMemory/interface/ROOTSerializer.h"
#include "FWCore/SharedMemory/interface/ROOTDeserializer.h"
#include "DataFormats/TestObjects/interface/Thing.h"
namespace {
struct ReadWriteTestBuffer {
std::pair<char*, std::size_t> buffer() { return std::pair(&buffer_.front(), size()); }
int bufferIdentifier() { return bufferIdentifier_; }
void copyToBuffer(char* iStart, std::size_t iLength) {
buffer_.clear();
if (iLength > buffer_.capacity()) {
buffer_.reserve(iLength);
++bufferIdentifier_;
}
std::copy(iStart, iStart + iLength, std::back_insert_iterator(buffer_));
}
std::size_t size() const { return buffer_.size(); }
std::vector<char> buffer_;
int bufferIdentifier_ = 1;
};
bool compare(std::vector<edmtest::Thing> const& iLHS, std::vector<edmtest::Thing> const& iRHS) {
if (iLHS.size() != iRHS.size()) {
return false;
}
for (size_t i = 0; i < iLHS.size(); ++i) {
if (iLHS[i].a != iRHS[i].a) {
return false;
}
}
return true;
}
} // namespace
using namespace edm::shared_memory;
TEST_CASE("test De/ROOTSerializer", "[ROOTSerializer]") {
SECTION("Process edmtest::Thing") {
ReadWriteTestBuffer buffer;
ROOTSerializer<edmtest::Thing, ReadWriteTestBuffer> serializer(buffer);
ROOTDeserializer<edmtest::Thing, ReadWriteTestBuffer> deserializer(buffer);
edmtest::Thing t;
t.a = 42;
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 2);
auto newT = deserializer.deserialize();
REQUIRE(t.a == newT.a);
SECTION("Reuse buffer") {
t.a = 12;
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 2);
auto newT = deserializer.deserialize();
REQUIRE(t.a == newT.a);
}
}
SECTION("Process std::vector<edmtest::Thing>") {
ReadWriteTestBuffer buffer;
ROOTSerializer<std::vector<edmtest::Thing>, ReadWriteTestBuffer> serializer(buffer);
ROOTDeserializer<std::vector<edmtest::Thing>, ReadWriteTestBuffer> deserializer(buffer);
std::vector<edmtest::Thing> t;
t.reserve(4);
for (int i = 0; i < 4; ++i) {
edmtest::Thing temp;
temp.a = i;
t.push_back(temp);
}
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 2);
auto newT = deserializer.deserialize();
REQUIRE(compare(t, newT));
SECTION("Reuse edtest::Thing buffer") {
for (auto& v : t) {
v.a += 1;
}
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 2);
auto newT = deserializer.deserialize();
REQUIRE(compare(t, newT));
}
SECTION("Grow") {
t.emplace_back();
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 3);
auto newT = deserializer.deserialize();
REQUIRE(compare(t, newT));
}
SECTION("Shrink") {
t.pop_back();
t.pop_back();
serializer.serialize(t);
REQUIRE(buffer.bufferIdentifier() == 2);
auto newT = deserializer.deserialize();
REQUIRE(compare(t, newT));
}
}
}
|