Plugins/Json/ProtoAxisJsonConverterTests.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/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Plugins/Json/ActsJson.hpp"
0013 #include "Acts/Plugins/Json/ProtoAxisJsonConverter.hpp"
0014 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0015 #include "Acts/Utilities/Axis.hpp"
0016 #include "Acts/Utilities/AxisDefinitions.hpp"
0017 #include "Acts/Utilities/ProtoAxis.hpp"
0018
0019 BOOST_AUTO_TEST_SUITE(ProtoAxisJsonConversion)
0020
0021 BOOST_AUTO_TEST_CASE(EquidistantProtoAxisJsonConversion) {
0022   using enum Acts::AxisBoundaryType;
0023   using enum Acts::AxisDirection;
0024   using enum Acts::AxisType;
0025
0026   // Bound, equidistant axis
0027   Acts::ProtoAxis epab(AxisX, Bound, 0.0, 1.0, 10);
0028
0029   nlohmann::json jProtoAxis = Acts::ProtoAxisJsonConverter::toJson(epab);
0030
0031   BOOST_CHECK(jProtoAxis.contains("axis"));
0032   BOOST_CHECK(jProtoAxis.contains("axis_dir"));
0033   BOOST_CHECK(jProtoAxis.contains("autorange"));
0034
0035   Acts::ProtoAxis epabRead = Acts::ProtoAxisJsonConverter::fromJson(jProtoAxis);
0036
0037   BOOST_CHECK_EQUAL(epabRead.getAxisDirection(), epab.getAxisDirection());
0038   BOOST_CHECK_EQUAL(epabRead.getAxis(), epab.getAxis());
0039   BOOST_CHECK_EQUAL(epabRead.isAutorange(), epab.isAutorange());
0040   BOOST_CHECK_EQUAL(epabRead.toString(), epab.toString());
0041 }
0042
0043 BOOST_AUTO_TEST_CASE(AutorangeProtoAxisJsonConversion) {
0044   using enum Acts::AxisBoundaryType;
0045   using enum Acts::AxisDirection;
0046   using enum Acts::AxisType;
0047
0048   // Bound, equidistant axis, autorange
0049   Acts::ProtoAxis epa(AxisX, Bound, 10);
0050
0051   nlohmann::json jProtoAxis = Acts::ProtoAxisJsonConverter::toJson(epa);
0052
0053   BOOST_CHECK(jProtoAxis.contains("axis"));
0054   BOOST_CHECK(jProtoAxis.contains("axis_dir"));
0055   BOOST_CHECK(jProtoAxis.contains("autorange"));
0056
0057   Acts::ProtoAxis epaRead = Acts::ProtoAxisJsonConverter::fromJson(jProtoAxis);
0058
0059   BOOST_CHECK_EQUAL(epaRead.getAxisDirection(), epa.getAxisDirection());
0060   BOOST_CHECK_EQUAL(epaRead.getAxis(), epa.getAxis());
0061   BOOST_CHECK_EQUAL(epaRead.isAutorange(), epa.isAutorange());
0062   BOOST_CHECK_EQUAL(epaRead.toString(), epa.toString());
0063 }
0064
0065 BOOST_AUTO_TEST_CASE(VariableProtoAxisJsonConversion) {
0066   using enum Acts::AxisBoundaryType;
0067   using enum Acts::AxisDirection;
0068   using enum Acts::AxisType;
0069
0070   // Bound, variable axis
0071   Acts::ProtoAxis vpab(AxisX, Bound, {0.0, 1.0, 10});
0072
0073   nlohmann::json jProtoAxis = Acts::ProtoAxisJsonConverter::toJson(vpab);
0074   BOOST_CHECK(jProtoAxis.contains("axis"));
0075   BOOST_CHECK(jProtoAxis.contains("axis_dir"));
0076   BOOST_CHECK(jProtoAxis.contains("autorange"));
0077
0078   Acts::ProtoAxis vpabRead = Acts::ProtoAxisJsonConverter::fromJson(jProtoAxis);
0079
0080   BOOST_CHECK_EQUAL(vpabRead.getAxisDirection(), vpab.getAxisDirection());
0081   BOOST_CHECK_EQUAL(vpabRead.getAxis(), vpab.getAxis());
0082   BOOST_CHECK_EQUAL(vpabRead.isAutorange(), vpab.isAutorange());
0083   BOOST_CHECK_EQUAL(vpabRead.toString(), vpab.toString());
0084 }
0085
0086 BOOST_AUTO_TEST_CASE(InvalidAndValidInputJson) {
0087   // valid eq axis input
0088   nlohmann::json jValidEqAxis = {{"bins", 10},
0089                                  {"boundary_type", "Bound"},
0090                                  {"range", std::array<double, 2>{0.0, 1.0}},
0091                                  {"type", "Equidistant"}};
0092
0093   // Valid input first
0094   nlohmann::json jValidEq = {
0095       {"axis", jValidEqAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0096
0097   BOOST_CHECK_NO_THROW(Acts::ProtoAxisJsonConverter::fromJson(jValidEq));
0098
0099   // Invalid input - zero bins
0100   nlohmann::json jInvalidEqAxis = jValidEqAxis;
0101   jInvalidEqAxis["bins"] = 0;
0102
0103   nlohmann::json jInvalidEq = {
0104       {"axis", jInvalidEqAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0105
0106   BOOST_CHECK_THROW(Acts::ProtoAxisJsonConverter::fromJson(jInvalidEq),
0107                     std::invalid_argument);
0108
0109   // Invalid input - auto range without bins
0110   jInvalidEq = {
0111       {"axis", jInvalidEqAxis}, {"axis_dir", "AxisX"}, {"autorange", true}};
0112   BOOST_CHECK_THROW(Acts::ProtoAxisJsonConverter::fromJson(jInvalidEq),
0113                     std::invalid_argument);
0114
0115   // Invalid input - min >= max
0116   jInvalidEqAxis = jValidEqAxis;
0117   jInvalidEqAxis["range"] = std::array<double, 2>{1.0, 0.0};
0118
0119   jInvalidEq = {
0120       {"axis", jInvalidEqAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0121
0122   BOOST_CHECK_THROW(Acts::ProtoAxisJsonConverter::fromJson(jInvalidEq),
0123                     std::invalid_argument);
0124
0125   nlohmann::json jValidVarAxis = {
0126       {"boundary_type", "Bound"},
0127       {"boundaries", std::vector<double>{0.0, 0.25, 0.75, 1.0}},
0128       {"type", "Variable"}};
0129
0130   // Valid input first
0131   nlohmann::json jValidVar = {
0132       {"axis", jValidVarAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0133   BOOST_CHECK_NO_THROW(Acts::ProtoAxisJsonConverter::fromJson(jValidVar));
0134
0135   // Invalid input - less than two edges
0136   nlohmann::json jInvalidVarAxis = jValidVarAxis;
0137   jInvalidVarAxis["boundaries"] = std::vector<double>{0.0};
0138
0139   nlohmann::json jInvalidVar = {
0140       {"axis", jInvalidVarAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0141   BOOST_CHECK_THROW(Acts::ProtoAxisJsonConverter::fromJson(jInvalidVar),
0142                     std::invalid_argument);
0143
0144   // Invalid input - non-increasing edges
0145   jInvalidVarAxis = jValidVarAxis;
0146   jInvalidVarAxis["boundaries"] = std::vector<double>{0.0, 0.75, 0.25, 1.0};
0147
0148   jInvalidVar = {
0149       {"axis", jInvalidVarAxis}, {"axis_dir", "AxisX"}, {"autorange", false}};
0150
0151   BOOST_CHECK_THROW(Acts::ProtoAxisJsonConverter::fromJson(jInvalidVar),
0152                     std::invalid_argument);
0153 }
0154
0155 BOOST_AUTO_TEST_SUITE_END()