Core/EventData/SpacePointContainer2Tests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/EventData/SourceLink.hpp"
0012 #include "Acts/EventData/SpacePointContainer2.hpp"
0013 #include "Acts/EventData/Types.hpp"
0014
0015 #include <stdexcept>
0016
0017 using namespace Acts;
0018
0019 namespace ActsTests {
0020
0021 BOOST_AUTO_TEST_SUITE(EventDataSuite)
0022
0023 BOOST_AUTO_TEST_CASE(Empty) {
0024   SpacePointContainer2 container;
0025
0026   BOOST_CHECK(container.empty());
0027   BOOST_CHECK_EQUAL(container.size(), 0u);
0028
0029   for ([[maybe_unused]] auto _ : container) {
0030     BOOST_FAIL("Container should be empty, no space points should be iterated");
0031   }
0032 }
0033
0034 BOOST_AUTO_TEST_CASE(Create) {
0035   SpacePointContainer2 container(SpacePointColumns::SourceLinks |
0036                                  SpacePointColumns::X | SpacePointColumns::Y |
0037                                  SpacePointColumns::Z);
0038   container.reserve(1);
0039
0040   {
0041     MutableSpacePointProxy2 sp = container.createSpacePoint();
0042     sp.assignSourceLinks(std::array<SourceLink, 1>{SourceLink(42)});
0043     sp.x() = 1;
0044     sp.y() = 2;
0045     sp.z() = 3;
0046   }
0047
0048   BOOST_CHECK(!container.empty());
0049   BOOST_CHECK_EQUAL(container.size(), 1u);
0050
0051   {
0052     MutableSpacePointProxy2 sp = container.at(0);
0053     BOOST_CHECK_EQUAL(sp.x(), 1);
0054     BOOST_CHECK_EQUAL(sp.y(), 2);
0055     BOOST_CHECK_EQUAL(sp.z(), 3);
0056     BOOST_CHECK_EQUAL(sp.sourceLinks().size(), 1u);
0057     BOOST_CHECK_EQUAL(sp.sourceLinks()[0].get<int>(), 42);
0058   }
0059 }
0060
0061 BOOST_AUTO_TEST_CASE(Iterate) {
0062   SpacePointContainer2 container(SpacePointColumns::SourceLinks |
0063                                  SpacePointColumns::X | SpacePointColumns::Y |
0064                                  SpacePointColumns::Z);
0065   container.reserve(1);
0066
0067   MutableSpacePointProxy2 sp = container.createSpacePoint();
0068   sp.assignSourceLinks(std::array<SourceLink, 1>{SourceLink(42)});
0069   sp.x() = 1;
0070   sp.y() = 2;
0071   sp.z() = 3;
0072
0073   auto it = container.begin();
0074   BOOST_CHECK(it != container.end());
0075   BOOST_CHECK_EQUAL((*it).x(), 1);
0076   ++it;
0077   BOOST_CHECK(it == container.end());
0078 }
0079
0080 BOOST_AUTO_TEST_CASE(CopyAndMove) {
0081   SpacePointContainer2 container;
0082   container.reserve(1);
0083
0084   container.createSpacePoint();
0085
0086   SpacePointContainer2 containerCopy = container;
0087   BOOST_CHECK(!containerCopy.empty());
0088   BOOST_CHECK_EQUAL(containerCopy.size(), 1u);
0089
0090   SpacePointContainer2 containerMove = std::move(container);
0091   BOOST_CHECK(!containerMove.empty());
0092   BOOST_CHECK_EQUAL(containerMove.size(), 1u);
0093   // original should be empty after move
0094   BOOST_CHECK(container.empty());
0095   BOOST_CHECK_EQUAL(container.size(), 0u);
0096   // copy should be unchanged
0097   BOOST_CHECK(!containerCopy.empty());
0098   BOOST_CHECK_EQUAL(containerCopy.size(), 1u);
0099 }
0100
0101 BOOST_AUTO_TEST_CASE(Clear) {
0102   SpacePointContainer2 container;
0103   container.reserve(1);
0104
0105   container.createSpacePoint();
0106
0107   container.clear();
0108
0109   BOOST_CHECK(container.empty());
0110   BOOST_CHECK_EQUAL(container.size(), 0u);
0111   for ([[maybe_unused]] auto _ : container) {
0112     BOOST_FAIL("Container should be empty, no space points should be iterated");
0113   }
0114 }
0115
0116 BOOST_AUTO_TEST_CASE(KnownExtraColumns) {
0117   SpacePointContainer2 container;
0118
0119   BOOST_CHECK(
0120       !container.hasColumns(SpacePointColumns::R | SpacePointColumns::Phi));
0121
0122   container.createColumns(SpacePointColumns::R | SpacePointColumns::Phi);
0123
0124   BOOST_CHECK(
0125       container.hasColumns(SpacePointColumns::R | SpacePointColumns::Phi));
0126
0127   MutableSpacePointProxy2 sp = container.createSpacePoint();
0128   sp.r() = 100;
0129
0130   BOOST_CHECK_EQUAL(sp.r(), 100);
0131   BOOST_CHECK_EQUAL(sp.phi(), 0);
0132 }
0133
0134 BOOST_AUTO_TEST_CASE(NamedExtraColumns) {
0135   SpacePointContainer2 container;
0136
0137   BOOST_CHECK(!container.hasColumn("extra1"));
0138   BOOST_CHECK(!container.hasColumn("extra2"));
0139
0140   auto extra1 = container.createColumn<int>("extra1");
0141
0142   BOOST_CHECK(container.hasColumn("extra1"));
0143   BOOST_CHECK(!container.hasColumn("extra2"));
0144
0145   MutableSpacePointProxy2 sp = container.createSpacePoint();
0146   sp.extra(extra1) = 100;
0147
0148   auto extra2 = container.createColumn<int>("extra2");
0149
0150   BOOST_CHECK(container.hasColumn("extra1"));
0151   BOOST_CHECK(container.hasColumn("extra2"));
0152
0153   BOOST_CHECK_EQUAL(sp.extra(extra1), 100);
0154   BOOST_CHECK_EQUAL(sp.extra(extra2), 0);
0155 }
0156
0157 BOOST_AUTO_TEST_CASE(ThrowOnCreateReservedColumn) {
0158   BOOST_CHECK_THROW(SpacePointContainer2().createColumn<int>("x"),
0159                     std::runtime_error);
0160   BOOST_CHECK_THROW(SpacePointContainer2().createColumn<int>("r"),
0161                     std::runtime_error);
0162 }
0163
0164 BOOST_AUTO_TEST_CASE(ThrowOnDropReservedColumn) {
0165   BOOST_CHECK_THROW(SpacePointContainer2().dropColumn("x"), std::runtime_error);
0166 }
0167
0168 BOOST_AUTO_TEST_CASE(ThrowOnDropNonExistingColumn) {
0169   BOOST_CHECK_THROW(SpacePointContainer2().dropColumn("foo"),
0170                     std::runtime_error);
0171 }
0172
0173 BOOST_AUTO_TEST_CASE(ZipIterate) {
0174   SpacePointContainer2 container(SpacePointColumns::X | SpacePointColumns::Y |
0175                                  SpacePointColumns::Z);
0176   container.reserve(3);
0177
0178   MutableSpacePointProxy2 sp1 = container.createSpacePoint();
0179   sp1.x() = 1;
0180   sp1.y() = 2;
0181   sp1.z() = 3;
0182
0183   MutableSpacePointProxy2 sp2 = container.createSpacePoint();
0184   sp2.x() = 4;
0185   sp2.y() = 5;
0186   sp2.z() = 6;
0187
0188   MutableSpacePointProxy2 sp3 = container.createSpacePoint();
0189   sp3.x() = 7;
0190   sp3.y() = 8;
0191   sp3.z() = 9;
0192
0193   BOOST_CHECK_EQUAL(container.size(), 3u);
0194
0195   SpacePointIndex2 checkIndex = 0;
0196   for (auto [i, x, y, z] : container.zip(
0197            container.xColumn(), container.yColumn(), container.zColumn())) {
0198     BOOST_CHECK_EQUAL(i, checkIndex);
0199     BOOST_CHECK_NE(x, 0);
0200     BOOST_CHECK_NE(y, 0);
0201     BOOST_CHECK_NE(z, 0);
0202
0203     ++checkIndex;
0204   }
0205 }
0206
0207 BOOST_AUTO_TEST_SUITE_END()
0208
0209 }  // namespace ActsTests