Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 }

◆ 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 }

◆ 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 }
AthenaPoolExample_Write.stream1
stream1
Definition: AthenaPoolExample_Write.py:118
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
AthenaPoolExample_Write.stream2
stream2
Definition: AthenaPoolExample_Write.py:126
TrigInDetValidation_Base.test
test
Definition: TrigInDetValidation_Base.py:147
parseMapping.v0
def v0
Definition: parseMapping.py:149
make_streamer
std::unique_ptr< JetStreamer > make_streamer(int test)
Definition: JetStreamerTest.cxx:13
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
JetStreamer
Definition: JetStreamer.h:25
Generated on Thu Apr 17 2025 21:23:56 for ATLAS Offline Software by   doxygen 1.8.18