ATLAS Offline Software
Loading...
Searching...
No Matches
Typedefs | Functions
JetStreamerTest.cxx File Reference
#include "gtest/gtest.h"
#include "TrigHLTJetHypo/../src/JetStreamer.h"
#include "TrigHLTJetHypo/../src/IJetStream.h"
#include <vector>
#include <memory>
Include dependency graph for JetStreamerTest.cxx:

Go to the source code of this file.

Typedefs

using vec = std::vector<std::size_t>

Functions

std::unique_ptr< JetStreamer > make_streamer (int test)
 TEST (JetStreamerTester, oneSimpleJetStream)
 TEST (JetStreamerTester, oneCombinationsJetStream)
 TEST (JetStreamerTester, twoSimpleJetStreams)
 TEST (JetStreamerTester, SimpleThenCombinationsJetStreams)
 TEST (JetStreamerTester, CombinationsThenSimpleJetStreams)
 TEST (JetStreamerTester, SimmpleThenCombinationsThenSimpleJetStreams)
 TEST (JetStreamerTester, InvalidJetIndices)
 TEST (JetStreamerTester, InvalidNchooseK)
 TEST (JetStreamerTester, InvalidJetStream)

Typedef Documentation

◆ vec

using vec = std::vector<std::size_t>

Definition at line 11 of file JetStreamerTest.cxx.

Function Documentation

◆ make_streamer()

std::unique_ptr< JetStreamer > make_streamer ( int test)

Definition at line 13 of file JetStreamerTest.cxx.

13 {
14
15 auto null_stream = std::unique_ptr<IJetStream>{nullptr};
16
17 auto streamer = std::unique_ptr<JetStreamer> (nullptr);
18
19 if (test == 0) {
20 std::vector<std::size_t> jets0 {1, 2};
21
22 auto stream0 = std::make_unique<SimpleJetStream>(jets0,
23 std::move(null_stream),
24 0
25 );
26 streamer = std::make_unique<JetStreamer>(std::move(stream0));
27
28 return streamer;
29 } else if (test == 1) {
30
31 std::vector<std::size_t> jets_cs {5, 6, 7};
32 std::size_t k2{2};
33
34 auto stream0 =
35 std::make_unique<CombinationsJetStream>(jets_cs,
36 std::move(null_stream),
37 k2,
38 0
39 );
40 streamer.reset(new JetStreamer(std::move(stream0)));
41 return streamer;
42 } else if (test == 2) {
43
44 std::vector<std::size_t> jets0 {1, 2};
45 std::vector<std::size_t> jets1 {3, 4};
46 auto stream1 =
47 std::make_unique<SimpleJetStream>(jets1,
48 std::move(null_stream),
49 1
50 );
51
52
53 auto stream0 =
54 std::make_unique<SimpleJetStream>(jets0,
55 std::move(stream1),
56 0
57 );
58
59 streamer.reset(new JetStreamer(std::move(stream0)));
60 return streamer;
61 } else if (test == 3) {
62
63 std::vector<std::size_t> jets_cs {5, 6, 7};
64 std::size_t k2{2};
65 std::vector<std::size_t> jets0 {1, 2};
66
67
68
69 auto stream1 =
70 std::make_unique<CombinationsJetStream>(jets_cs,
71 std::move(null_stream),
72 k2,
73 1
74 );
75
76
77 auto stream0 =
78 std::make_unique<SimpleJetStream>(jets0,
79 std::move(stream1),
80 0
81 );
82
83 streamer.reset(new JetStreamer(std::move(stream0)));
84 return streamer;
85 } else if (test == 4) {
86
87 std::vector<std::size_t> jets_cs {5, 6, 7};
88 std::size_t k2{2};
89 std::vector<std::size_t> jets0 {1, 2};
90
91
92 auto stream1 =
93 std::make_unique<SimpleJetStream>(jets0,
94 std::move(null_stream),
95 1
96 );
97
98
99 auto stream0 =
100 std::make_unique<CombinationsJetStream>(jets_cs,
101 std::move(stream1),
102 k2,
103 0
104 );
105
106 streamer.reset(new JetStreamer(std::move(stream0)));
107 return streamer;
108 } else if (test == 5) {
109
110
111 std::vector<std::size_t> jets_cs {5, 6, 7};
112 std::size_t k2{2};
113 std::vector<std::size_t> jets0 {1, 2};
114 std::vector<std::size_t> jets1 {3, 4};
115
116 auto stream2 =
117 std::make_unique<SimpleJetStream>(jets1,
118 std::move(null_stream),
119 2
120 );
121
122 auto stream1 =
123 std::make_unique<CombinationsJetStream>(jets_cs,
124 std::move(stream2),
125 k2,
126 1
127 );
128
129
130 auto stream0 =
131 std::make_unique<SimpleJetStream>(jets0,
132 std::move(stream1),
133 0
134 );
135
136 streamer.reset(new JetStreamer(std::move(stream0)));
137
138 return streamer;
139 } else if (test == 6) {
140
141
142 std::vector<std::size_t> jets_cs {};
143 std::size_t k2{2};
144 std::vector<std::size_t> jets0 {1, 2};
145 std::vector<std::size_t> jets1 {3, 4};
146
147 auto stream2 =
148 std::make_unique<SimpleJetStream>(jets1,
149 std::move(null_stream),
150 2
151 );
152
153 auto stream1 =
154 std::make_unique<CombinationsJetStream>(jets_cs,
155 std::move(stream2),
156 k2,
157 1
158 );
159
160
161 auto stream0 =
162 std::make_unique<SimpleJetStream>(jets0,
163 std::move(stream1),
164 0
165 );
166
167 streamer.reset(new JetStreamer(std::move(stream0)));
168
169 return streamer;
170 } else if (test == 7) {
171
172
173 std::vector<std::size_t> jets_cs {5, 6, 7};
174 std::size_t k4{4};
175 std::vector<std::size_t> jets0 {1, 2};
176 std::vector<std::size_t> jets1 {3, 4};
177
178 auto stream2 =
179 std::make_unique<SimpleJetStream>(jets1,
180 std::move(null_stream),
181 2
182 );
183
184 auto stream1 =
185 std::make_unique<CombinationsJetStream>(jets_cs,
186 std::move(stream2),
187 k4,
188 1
189 );
190
191
192 auto stream0 =
193 std::make_unique<SimpleJetStream>(jets0,
194 std::move(stream1),
195 0
196 );
197
198 streamer.reset(new JetStreamer(std::move(stream0)));
199
200 return streamer;
201 } else if (test == 8) {
202
203 auto stream0 = std::unique_ptr<IJetStream>(nullptr);
204 streamer.reset(new JetStreamer(std::move(stream0)));
205 return streamer;
206 } else {
207 std::cerr << "unknown test << " << test << '\n';
208 return streamer;
209 }
210}
TrigInDetValidation_Base.test
test
Definition TrigInDetValidation_Base.py:142

◆ TEST() [1/9]

TEST ( JetStreamerTester ,
CombinationsThenSimpleJetStreams  )

Definition at line 268 of file JetStreamerTest.cxx.

268 {
269 // Cycle around the input vector
270 auto streamer = make_streamer(4);
271 vec v0{1, 5, 6};
272 vec v1{2, 5, 6};
273 vec v2{1, 5, 7};
274 vec v3{2, 5, 7};
275 vec v4{1, 6, 7};
276 vec v5{2, 6, 7};
277
278 EXPECT_EQ (v0, streamer->next());
279 EXPECT_EQ (v1, streamer->next());
280 EXPECT_EQ (v2, streamer->next());
281 EXPECT_EQ (v3, streamer->next());
282 EXPECT_EQ (v4, streamer->next());
283 EXPECT_EQ (v5, streamer->next());
284 EXPECT_EQ (vec{}, streamer->next());
285}
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
make_streamer
std::unique_ptr< JetStreamer > make_streamer(int test)
Definition JetStreamerTest.cxx:13

◆ TEST() [2/9]

TEST ( JetStreamerTester ,
InvalidJetIndices  )

Definition at line 318 of file JetStreamerTest.cxx.

318 {
319 // Cycle around the input vector
320 auto streamer = make_streamer(6);
321 EXPECT_EQ (vec{}, streamer->next());
322}

◆ TEST() [3/9]

TEST ( JetStreamerTester ,
InvalidJetStream  )

Definition at line 331 of file JetStreamerTest.cxx.

331 {
332 // Cycle around the input vector
333 auto streamer = make_streamer(8);
334 EXPECT_EQ (vec{}, streamer->next());
335}

◆ TEST() [4/9]

TEST ( JetStreamerTester ,
InvalidNchooseK  )

Definition at line 325 of file JetStreamerTest.cxx.

325 {
326 // Cycle around the input vector
327 auto streamer = make_streamer(7);
328 EXPECT_EQ (vec{}, streamer->next());
329}

◆ TEST() [5/9]

TEST ( JetStreamerTester ,
oneCombinationsJetStream  )

Definition at line 221 of file JetStreamerTest.cxx.

221 {
222 // Cycle around the input vector
223 auto streamer = make_streamer(1);
224 vec v0{5, 6};
225 vec v1{5, 7};
226 vec v2{6, 7};
227 EXPECT_EQ (v0, streamer->next());
228 EXPECT_EQ (v1, streamer->next());
229 EXPECT_EQ (v2, streamer->next());
230 EXPECT_EQ (vec{}, streamer->next());
231}

◆ TEST() [6/9]

TEST ( JetStreamerTester ,
oneSimpleJetStream  )

Definition at line 212 of file JetStreamerTest.cxx.

212 {
213 // Cycle around the input vector
214 auto streamer = make_streamer(0);
215 EXPECT_EQ (vec{1}, streamer->next());
216 EXPECT_EQ (vec{2}, streamer->next());
217 EXPECT_EQ (vec{}, streamer->next());
218}

◆ TEST() [7/9]

TEST ( JetStreamerTester ,
SimmpleThenCombinationsThenSimpleJetStreams  )

Definition at line 287 of file JetStreamerTest.cxx.

287 {
288 // Cycle around the input vector
289 auto streamer = make_streamer(5);
290 vec v0{3, 5, 6, 1};
291 vec v1{4, 5, 6, 1};
292 vec v2{3, 5, 7, 1};
293 vec v3{4, 5, 7, 1};
294 vec v4{3, 6, 7, 1};
295 vec v5{4, 6, 7, 1};
296 vec v6{3, 5, 6, 2};
297 vec v7{4, 5, 6, 2};
298 vec v8{3, 5, 7, 2};
299 vec v9{4, 5, 7, 2};
300 vec v10{3, 6, 7, 2};
301 vec v11{4, 6, 7, 2};
302
303 EXPECT_EQ (v0, streamer->next());
304 EXPECT_EQ (v1, streamer->next());
305 EXPECT_EQ (v2, streamer->next());
306 EXPECT_EQ (v3, streamer->next());
307 EXPECT_EQ (v4, streamer->next());
308 EXPECT_EQ (v5, streamer->next());
309 EXPECT_EQ (v6, streamer->next());
310 EXPECT_EQ (v7, streamer->next());
311 EXPECT_EQ (v8, streamer->next());
312 EXPECT_EQ (v9, streamer->next());
313 EXPECT_EQ (v10, streamer->next());
314 EXPECT_EQ (v11, streamer->next());
315 EXPECT_EQ (vec{}, streamer->next());
316}

◆ TEST() [8/9]

TEST ( JetStreamerTester ,
SimpleThenCombinationsJetStreams  )

Definition at line 249 of file JetStreamerTest.cxx.

249 {
250 // Cycle around the input vector
251 auto streamer = make_streamer(3);
252 vec v0{5, 6, 1};
253 vec v1{5, 7, 1};
254 vec v2{6, 7, 1};
255 vec v3{5, 6, 2};
256 vec v4{5, 7, 2};
257 vec v5{6, 7, 2};
258
259 EXPECT_EQ (v0, streamer->next());
260 EXPECT_EQ (v1, streamer->next());
261 EXPECT_EQ (v2, streamer->next());
262 EXPECT_EQ (v3, streamer->next());
263 EXPECT_EQ (v4, streamer->next());
264 EXPECT_EQ (v5, streamer->next());
265 EXPECT_EQ (vec{}, streamer->next());
266}

◆ TEST() [9/9]

TEST ( JetStreamerTester ,
twoSimpleJetStreams  )

Definition at line 234 of file JetStreamerTest.cxx.

234 {
235 // Cycle around the input vector
236 auto streamer = make_streamer(2);
237 vec v0{3, 1};
238 vec v1{4, 1};
239 vec v2{3, 2};
240 vec v3{4, 2};
241
242 EXPECT_EQ (v0, streamer->next());
243 EXPECT_EQ (v1, streamer->next());
244 EXPECT_EQ (v2, streamer->next());
245 EXPECT_EQ (v3, streamer->next());
246 EXPECT_EQ (vec{}, streamer->next());
247}
Generated on for ATLAS Offline Software by doxygen 1.14.0