Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/ |
| 3 | * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/ |
| 4 | * |
| 5 | * Written by Václav Kubernát <kubervac@fit.cvut.cz> |
| 6 | * |
| 7 | */ |
| 8 | |
Václav Kubernát | 26b5608 | 2020-02-03 18:28:56 +0100 | [diff] [blame] | 9 | #include "trompeloeil_doctest.hpp" |
Jan Kundrát | 76b3ddc | 2019-07-03 10:31:27 +0200 | [diff] [blame] | 10 | #include <boost/core/demangle.hpp> |
Václav Kubernát | 24df80e | 2018-06-06 15:18:03 +0200 | [diff] [blame] | 11 | #include "ast_commands.hpp" |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 12 | #include "leaf_data_helpers.hpp" |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 13 | #include "parser.hpp" |
Václav Kubernát | ed824d0 | 2020-06-09 15:48:30 +0200 | [diff] [blame] | 14 | #include "pretty_printers.hpp" |
Václav Kubernát | bddbb17 | 2018-06-13 16:27:39 +0200 | [diff] [blame] | 15 | #include "static_schema.hpp" |
Václav Kubernát | 509ce65 | 2019-05-29 19:46:44 +0200 | [diff] [blame] | 16 | #include "utils.hpp" |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 17 | |
| 18 | TEST_CASE("leaf editing") |
| 19 | { |
Václav Kubernát | bddbb17 | 2018-06-13 16:27:39 +0200 | [diff] [blame] | 20 | auto schema = std::make_shared<StaticSchema>(); |
Václav Kubernát | 744f57f | 2018-06-29 22:46:26 +0200 | [diff] [blame] | 21 | schema->addModule("mod"); |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 22 | schema->addModule("pizza-module"); |
Václav Kubernát | efcac93 | 2020-01-10 15:26:32 +0100 | [diff] [blame] | 23 | schema->addContainer("/", "mod:contA"); |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 24 | schema->addLeaf("/", "mod:leafString", yang::String{}); |
| 25 | schema->addLeaf("/", "mod:leafDecimal", yang::Decimal{}); |
| 26 | schema->addLeaf("/", "mod:leafBool", yang::Bool{}); |
| 27 | schema->addLeaf("/", "mod:leafInt8", yang::Int8{}); |
| 28 | schema->addLeaf("/", "mod:leafInt16", yang::Int16{}); |
| 29 | schema->addLeaf("/", "mod:leafInt32", yang::Int32{}); |
| 30 | schema->addLeaf("/", "mod:leafInt64", yang::Int64{}); |
| 31 | schema->addLeaf("/", "mod:leafUint8", yang::Uint8{}); |
| 32 | schema->addLeaf("/", "mod:leafUint16", yang::Uint16{}); |
| 33 | schema->addLeaf("/", "mod:leafUint32", yang::Uint32{}); |
| 34 | schema->addLeaf("/", "mod:leafUint64", yang::Uint64{}); |
| 35 | schema->addLeaf("/", "mod:leafBinary", yang::Binary{}); |
Václav Kubernát | 222ecff | 2020-05-14 23:14:35 +0200 | [diff] [blame] | 36 | schema->addIdentity(std::nullopt, identityRef_{"mod", "food"}); |
| 37 | schema->addIdentity(std::nullopt, identityRef_{"mod", "vehicle"}); |
| 38 | schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "pizza"}); |
| 39 | schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "spaghetti"}); |
| 40 | schema->addIdentity(identityRef_{"mod", "pizza"}, identityRef_{"pizza-module", "hawaii"}); |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 41 | schema->addLeaf("/", "mod:foodIdentRef", yang::IdentityRef{schema->validIdentities("mod", "food")}); |
| 42 | schema->addLeaf("/", "mod:pizzaIdentRef", yang::IdentityRef{schema->validIdentities("mod", "pizza")}); |
| 43 | schema->addLeaf("/mod:contA", "mod:identInCont", yang::IdentityRef{schema->validIdentities("mod", "pizza")}); |
| 44 | schema->addLeaf("/", "mod:leafEnum", createEnum({"lol", "data", "coze"})); |
| 45 | schema->addLeaf("/mod:contA", "mod:leafInCont", yang::String{}); |
Václav Kubernát | efcac93 | 2020-01-10 15:26:32 +0100 | [diff] [blame] | 46 | schema->addList("/", "mod:list", {"number"}); |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 47 | schema->addLeaf("/mod:list", "mod:number", yang::Int32{}); |
| 48 | schema->addLeaf("/mod:list", "mod:leafInList", yang::String{}); |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 49 | schema->addLeaf("/", "mod:refToString", yang::LeafRef{"/mod:leafString", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafString"))}); |
| 50 | schema->addLeaf("/", "mod:refToInt8", yang::LeafRef{"/mod:leafInt8", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafInt8"))}); |
| 51 | schema->addLeaf("/", "mod:refToLeafInCont", yang::LeafRef{"/mod:contA/identInCont", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:contA/mod:identInCont"))}); |
| 52 | schema->addLeaf("/", "mod:intOrString", yang::Union{{yang::TypeInfo{yang::Int32{}}, yang::TypeInfo{yang::String{}}}}); |
| 53 | schema->addLeaf("/", "mod:twoInts", yang::Union{{yang::TypeInfo{yang::Uint8{}}, yang::TypeInfo{yang::Int16{}}}}); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 54 | schema->addLeaf("/", "mod:unionStringEnumLeafref", yang::Union{{ |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 55 | yang::LeafDataType{yang::String{}}, |
| 56 | yang::LeafDataType{createEnum({"foo", "bar"})}, |
| 57 | yang::LeafDataType{yang::LeafRef{"/mod:leafEnum", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafEnum"))}} |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 58 | }}); |
| 59 | |
| 60 | schema->addList("/", "mod:portSettings", {"port"}); |
| 61 | schema->addLeaf("/mod:portSettings", "mod:port", createEnum({"eth0", "eth1", "eth2"})); |
| 62 | schema->addList("/", "mod:portMapping", {"port"}); |
| 63 | schema->addLeaf("/mod:portMapping", "mod:port", createEnum({"utf1", "utf2", "utf3"})); |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 64 | schema->addLeaf("/", "mod:activeMappedPort", yang::LeafRef{"/mod:portMapping/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portMapping/mod:port"))}); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 65 | schema->addLeaf("/", "mod:activePort", yang::Union{{ |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 66 | yang::TypeInfo{createEnum({"wlan0", "wlan1"})}, |
| 67 | yang::TypeInfo{yang::LeafRef{"/mod:portSettings/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portSettings/mod:port"))}}, |
| 68 | yang::TypeInfo{yang::LeafRef{"/mod:activeMappedPort", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:activeMappedPort"))}}, |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 69 | yang::TypeInfo{yang::Empty{}}, |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 70 | }}); |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 71 | schema->addLeaf("/", "mod:dummy", yang::Empty{}); |
Václav Kubernát | abf5280 | 2020-05-19 01:31:17 +0200 | [diff] [blame] | 72 | schema->addLeaf("/", "mod:readonly", yang::Int32{}, yang::AccessType::ReadOnly); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 73 | |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 74 | schema->addLeaf("/", "mod:flags", yang::Bits{{"carry", "sign"}}); |
| 75 | |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 76 | Parser parser(schema); |
| 77 | std::string input; |
| 78 | std::ostringstream errorStream; |
| 79 | |
| 80 | SECTION("valid input") |
| 81 | { |
| 82 | set_ expected; |
Jan Kundrát | 03c77a1 | 2023-08-28 14:23:05 +0200 | [diff] [blame^] | 83 | dataPath_ cwd; |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 84 | |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 85 | SECTION("set mod:leafString \"some_data\"") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 86 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 87 | input = "set mod:leafString \'some_data\'"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 88 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 89 | expected.m_data = std::string("some_data"); |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 90 | } |
| 91 | |
Jan Kundrát | 03c77a1 | 2023-08-28 14:23:05 +0200 | [diff] [blame^] | 92 | SECTION("cd mod:contA; set leafInCont 'x'") |
| 93 | { |
| 94 | input = "set leafInCont 'x'"; |
| 95 | cwd.m_nodes.emplace_back(module_{"mod"}, container_{"contA"}); |
| 96 | expected.m_path.m_nodes.emplace_back(leaf_("leafInCont")); |
| 97 | expected.m_data = std::string("x"); |
| 98 | } |
| 99 | |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 100 | SECTION("set mod:contA/leafInCont 'more_data'") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 101 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 102 | input = "set mod:contA/leafInCont 'more_data'"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 103 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA")); |
| 104 | expected.m_path.m_nodes.emplace_back(leaf_("leafInCont")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 105 | expected.m_data = std::string("more_data"); |
| 106 | } |
| 107 | |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 108 | SECTION("set mod:contA/leafInCont \"data with' a quote\"") |
Václav Kubernát | c18ffac | 2020-01-10 16:06:06 +0100 | [diff] [blame] | 109 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 110 | input = "set mod:contA/leafInCont \"data with' a quote\""; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 111 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA")); |
| 112 | expected.m_path.m_nodes.emplace_back(leaf_("leafInCont")); |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 113 | expected.m_data = std::string("data with' a quote"); |
| 114 | } |
| 115 | |
| 116 | SECTION("set mod:contA/leafInCont 'data with\" a quote'") |
| 117 | { |
| 118 | input = "set mod:contA/leafInCont 'data with\" a quote'"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 119 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA")); |
| 120 | expected.m_path.m_nodes.emplace_back(leaf_("leafInCont")); |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 121 | expected.m_data = std::string("data with\" a quote"); |
| 122 | } |
| 123 | |
| 124 | SECTION("set mod:contA/leafInCont 'more d\tata'") // spaces in string |
| 125 | { |
| 126 | input = "set mod:contA/leafInCont 'more d\tata'"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 127 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA")); |
| 128 | expected.m_path.m_nodes.emplace_back(leaf_("leafInCont")); |
Václav Kubernát | c18ffac | 2020-01-10 16:06:06 +0100 | [diff] [blame] | 129 | expected.m_data = std::string("more d\tata"); |
| 130 | } |
| 131 | |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 132 | SECTION("set mod:list[number=1]/leafInList \"another_data\"") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 133 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 134 | input = "set mod:list[number=1]/leafInList \"another_data\""; |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 135 | auto keys = ListInstance{ |
Václav Kubernát | 7707cae | 2020-01-16 12:04:53 +0100 | [diff] [blame] | 136 | {"number", int32_t{1}}}; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 137 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, listElement_("list", keys)); |
| 138 | expected.m_path.m_nodes.emplace_back(leaf_("leafInList")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 139 | expected.m_data = std::string("another_data"); |
| 140 | } |
| 141 | |
| 142 | SECTION("data types") |
| 143 | { |
| 144 | SECTION("string") |
| 145 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 146 | input = "set mod:leafString \"somedata\""; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 147 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 148 | expected.m_data = std::string("somedata"); |
| 149 | } |
| 150 | |
Václav Kubernát | b8bad06 | 2021-02-04 00:02:45 +0100 | [diff] [blame] | 151 | SECTION("more spaces before value") |
| 152 | { |
| 153 | input = "set mod:leafString \"somedata\""; |
| 154 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString")); |
| 155 | expected.m_data = std::string("somedata"); |
| 156 | } |
| 157 | |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 158 | SECTION("int8") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 159 | { |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 160 | input = "set mod:leafInt8 2"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 161 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 162 | expected.m_data = int8_t{2}; |
| 163 | } |
| 164 | |
| 165 | SECTION("negative int8") |
| 166 | { |
| 167 | input = "set mod:leafInt8 -10"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 168 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 169 | expected.m_data = int8_t{-10}; |
| 170 | } |
| 171 | |
| 172 | SECTION("uint8") |
| 173 | { |
| 174 | input = "set mod:leafUint8 2"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 175 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint8")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 176 | expected.m_data = uint8_t{2}; |
| 177 | } |
| 178 | |
| 179 | SECTION("int16") |
| 180 | { |
| 181 | input = "set mod:leafInt16 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 182 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt16")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 183 | expected.m_data = int16_t{30'000}; |
| 184 | } |
| 185 | |
| 186 | SECTION("uint16") |
| 187 | { |
| 188 | input = "set mod:leafUint16 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 189 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint16")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 190 | expected.m_data = uint16_t{30'000}; |
| 191 | } |
| 192 | |
| 193 | SECTION("int32") |
| 194 | { |
| 195 | input = "set mod:leafInt32 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 196 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 197 | expected.m_data = int32_t{30'000}; |
| 198 | } |
| 199 | |
| 200 | SECTION("uint32") |
| 201 | { |
| 202 | input = "set mod:leafUint32 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 203 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint32")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 204 | expected.m_data = uint32_t{30'000}; |
| 205 | } |
| 206 | |
| 207 | SECTION("int32") |
| 208 | { |
| 209 | input = "set mod:leafInt32 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 210 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 211 | expected.m_data = int32_t{30'000}; |
| 212 | } |
| 213 | |
| 214 | SECTION("uint64") |
| 215 | { |
| 216 | input = "set mod:leafUint64 30000"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 217 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint64")); |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 218 | expected.m_data = uint64_t{30'000}; |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | SECTION("decimal") |
| 222 | { |
Václav Kubernát | 744f57f | 2018-06-29 22:46:26 +0200 | [diff] [blame] | 223 | input = "set mod:leafDecimal 3.14159"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 224 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafDecimal")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 225 | expected.m_data = 3.14159; |
| 226 | } |
| 227 | |
| 228 | SECTION("enum") |
| 229 | { |
Václav Kubernát | 744f57f | 2018-06-29 22:46:26 +0200 | [diff] [blame] | 230 | input = "set mod:leafEnum coze"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 231 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafEnum")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 232 | expected.m_data = enum_("coze"); |
| 233 | } |
| 234 | |
| 235 | SECTION("bool") |
| 236 | { |
Václav Kubernát | 744f57f | 2018-06-29 22:46:26 +0200 | [diff] [blame] | 237 | input = "set mod:leafBool true"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 238 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBool")); |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 239 | expected.m_data = true; |
| 240 | } |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 241 | |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 242 | SECTION("union") |
| 243 | { |
| 244 | SECTION("int") |
| 245 | { |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 246 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString")); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 247 | input = "set mod:intOrString 90"; |
| 248 | expected.m_data = int32_t{90}; |
| 249 | } |
| 250 | SECTION("string") |
| 251 | { |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 252 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString")); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 253 | input = "set mod:intOrString \"test\""; |
| 254 | expected.m_data = std::string{"test"}; |
| 255 | } |
| 256 | |
| 257 | SECTION("union with two integral types") |
| 258 | { |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 259 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("twoInts")); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 260 | SECTION("uint8") |
| 261 | { |
| 262 | input = "set mod:twoInts 100"; |
| 263 | expected.m_data = uint8_t{100}; |
| 264 | } |
| 265 | SECTION("int16") |
| 266 | { |
| 267 | input = "set mod:twoInts 6666"; |
| 268 | expected.m_data = int16_t{6666}; |
| 269 | } |
| 270 | } |
| 271 | |
| 272 | SECTION("union with enum and leafref to enum") |
| 273 | { |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 274 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("unionStringEnumLeafref")); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 275 | SECTION("string") |
| 276 | { |
| 277 | input = "set mod:unionStringEnumLeafref \"AHOJ\""; |
| 278 | expected.m_data = std::string{"AHOJ"}; |
| 279 | } |
| 280 | SECTION("enum") |
| 281 | { |
| 282 | input = "set mod:unionStringEnumLeafref bar"; |
| 283 | expected.m_data = enum_("bar"); |
| 284 | } |
| 285 | SECTION("enum leafref") |
| 286 | { |
| 287 | input = "set mod:unionStringEnumLeafref coze"; |
| 288 | expected.m_data = enum_("coze"); |
| 289 | } |
| 290 | } |
| 291 | |
| 292 | SECTION("activePort") |
| 293 | { |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 294 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("activePort")); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 295 | input = "set mod:activePort "; |
| 296 | SECTION("1. anonymous enum") |
| 297 | { |
| 298 | SECTION("wlan0") |
| 299 | { |
| 300 | input += "wlan0"; |
| 301 | expected.m_data = enum_("wlan0"); |
| 302 | } |
| 303 | SECTION("wlan1") |
| 304 | { |
| 305 | input += "wlan1"; |
| 306 | expected.m_data = enum_("wlan1"); |
| 307 | } |
| 308 | } |
| 309 | SECTION("2. leafref to enum") |
| 310 | { |
| 311 | SECTION("eth0") |
| 312 | { |
| 313 | input += "eth0"; |
| 314 | expected.m_data = enum_("eth0"); |
| 315 | } |
| 316 | SECTION("eth1") |
| 317 | { |
| 318 | input += "eth1"; |
| 319 | expected.m_data = enum_("eth1"); |
| 320 | } |
| 321 | SECTION("eth2") |
| 322 | { |
| 323 | input += "eth2"; |
| 324 | expected.m_data = enum_("eth2"); |
| 325 | } |
| 326 | } |
| 327 | SECTION("3. leafref to leafref") |
| 328 | { |
| 329 | SECTION("utf1") |
| 330 | { |
| 331 | input += "utf1"; |
| 332 | expected.m_data = enum_("utf1"); |
| 333 | } |
| 334 | SECTION("utf2") |
| 335 | { |
| 336 | input += "utf2"; |
| 337 | expected.m_data = enum_("utf2"); |
| 338 | } |
| 339 | SECTION("utf3") |
| 340 | { |
| 341 | input += "utf3"; |
| 342 | expected.m_data = enum_("utf3"); |
| 343 | } |
| 344 | } |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 345 | SECTION("4. empty") |
| 346 | { |
| 347 | expected.m_data = empty_{}; |
| 348 | } |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 349 | } |
| 350 | } |
| 351 | |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 352 | SECTION("binary") |
| 353 | { |
| 354 | SECTION("zero ending '='") |
| 355 | { |
| 356 | input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++"; |
| 357 | expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++"}; |
| 358 | } |
| 359 | |
| 360 | SECTION("one ending '='") |
| 361 | { |
| 362 | input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++="; |
| 363 | expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++="}; |
| 364 | } |
| 365 | |
| 366 | SECTION("two ending '='") |
| 367 | { |
| 368 | input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++=="; |
| 369 | expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++=="}; |
| 370 | } |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 371 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBinary")); |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 372 | } |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 373 | |
| 374 | SECTION("identityRef") |
| 375 | { |
| 376 | SECTION("foodIdentRef") |
| 377 | { |
| 378 | input = "set mod:foodIdentRef "; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 379 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("foodIdentRef")); |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 380 | |
| 381 | SECTION("food") |
| 382 | { |
| 383 | input += "food"; |
| 384 | expected.m_data = identityRef_("food"); |
| 385 | } |
| 386 | SECTION("mod:food") |
| 387 | { |
| 388 | input += "mod:food"; |
| 389 | expected.m_data = identityRef_("mod", "food"); |
| 390 | } |
| 391 | SECTION("pizza") |
| 392 | { |
| 393 | input += "pizza"; |
| 394 | expected.m_data = identityRef_("pizza"); |
| 395 | } |
| 396 | SECTION("mod:pizza") |
| 397 | { |
| 398 | input += "mod:pizza"; |
| 399 | expected.m_data = identityRef_("mod", "pizza"); |
| 400 | } |
| 401 | SECTION("pizza-module:hawaii") |
| 402 | { |
| 403 | input += "pizza-module:hawaii"; |
| 404 | expected.m_data = identityRef_("pizza-module", "hawaii"); |
| 405 | } |
| 406 | } |
| 407 | SECTION("pizzaIdentRef") |
| 408 | { |
| 409 | input = "set mod:pizzaIdentRef "; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 410 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("pizzaIdentRef")); |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 411 | SECTION("pizza") |
| 412 | { |
| 413 | input += "pizza"; |
| 414 | expected.m_data = identityRef_("pizza"); |
| 415 | } |
| 416 | SECTION("mod:pizza") |
| 417 | { |
| 418 | input += "mod:pizza"; |
| 419 | expected.m_data = identityRef_("mod", "pizza"); |
| 420 | } |
| 421 | SECTION("pizza-module:hawaii") |
| 422 | { |
| 423 | input += "pizza-module:hawaii"; |
| 424 | expected.m_data = identityRef_("pizza-module", "hawaii"); |
| 425 | } |
| 426 | } |
| 427 | SECTION("mod:contA/identInCont") |
| 428 | { |
| 429 | input = "set mod:contA/identInCont "; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 430 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA")); |
| 431 | expected.m_path.m_nodes.emplace_back(leaf_("identInCont")); |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 432 | SECTION("pizza") |
| 433 | { |
| 434 | input += "pizza"; |
| 435 | expected.m_data = identityRef_("pizza"); |
| 436 | } |
| 437 | SECTION("mod:pizza") |
| 438 | { |
| 439 | input += "mod:pizza"; |
| 440 | expected.m_data = identityRef_("mod", "pizza"); |
| 441 | } |
| 442 | SECTION("pizza-module:hawaii") |
| 443 | { |
| 444 | input += "pizza-module:hawaii"; |
| 445 | expected.m_data = identityRef_("pizza-module", "hawaii"); |
| 446 | } |
| 447 | } |
| 448 | } |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 449 | SECTION("leafRef") |
| 450 | { |
| 451 | SECTION("refToString") |
| 452 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 453 | input = "set mod:refToString \"blabal\""; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 454 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToString")); |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 455 | expected.m_data = std::string("blabal"); |
| 456 | } |
| 457 | |
| 458 | SECTION("refToInt8") |
| 459 | { |
| 460 | input = "set mod:refToInt8 42"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 461 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToInt8")); |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 462 | expected.m_data = int8_t{42}; |
| 463 | } |
Václav Kubernát | 2d7b05c | 2020-04-05 14:02:37 +0200 | [diff] [blame] | 464 | |
| 465 | SECTION("refToLeafInCont") |
| 466 | { |
| 467 | input = "set mod:refToLeafInCont pizza"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 468 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToLeafInCont")); |
Václav Kubernát | 2d7b05c | 2020-04-05 14:02:37 +0200 | [diff] [blame] | 469 | expected.m_data = identityRef_{"pizza"}; |
| 470 | } |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 471 | } |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 472 | SECTION("empty") |
| 473 | { |
| 474 | input = "set mod:dummy "; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 475 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("dummy")); |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 476 | expected.m_data = empty_{}; |
| 477 | } |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 478 | |
| 479 | SECTION("bits") |
| 480 | { |
| 481 | input = "set mod:flags "; |
| 482 | decltype(bits_::m_bits) bits; |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 483 | SECTION("<nothing>") |
| 484 | { |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 485 | bits = {}; |
| 486 | } |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 487 | SECTION("carry") |
| 488 | { |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 489 | input += "carry"; |
| 490 | bits = {"carry"}; |
| 491 | } |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 492 | SECTION("sign") |
| 493 | { |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 494 | input += "sign"; |
| 495 | bits = {"sign"}; |
| 496 | } |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 497 | SECTION("carry sign") |
| 498 | { |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 499 | input += "carry sign"; |
| 500 | bits = {"carry", "sign"}; |
| 501 | } |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 502 | SECTION("sign carry") |
| 503 | { |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 504 | input += "sign carry"; |
| 505 | bits = {"sign", "carry"}; |
| 506 | } |
| 507 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("flags")); |
| 508 | expected.m_data = bits_{bits}; |
| 509 | } |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 510 | } |
| 511 | |
Jan Kundrát | 03c77a1 | 2023-08-28 14:23:05 +0200 | [diff] [blame^] | 512 | parser.changeNode(cwd); |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 513 | command_ command = parser.parseCommand(input, errorStream); |
| 514 | REQUIRE(command.type() == typeid(set_)); |
| 515 | REQUIRE(boost::get<set_>(command) == expected); |
| 516 | } |
| 517 | |
| 518 | SECTION("invalid input") |
| 519 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 520 | std::string expectedError; |
Jan Kundrát | 03c77a1 | 2023-08-28 14:23:05 +0200 | [diff] [blame^] | 521 | dataPath_ cwd; |
| 522 | |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 523 | SECTION("missing space between a command and its arguments") |
| 524 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 525 | SECTION("setmod:leafString some_data") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 526 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 527 | input = "setmod:leafString 'some_data'"; |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 528 | } |
| 529 | } |
| 530 | |
| 531 | SECTION("missing space between arguments") |
| 532 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 533 | SECTION("set mod:leafString'lol'") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 534 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 535 | input = "set mod:leafString'lol'"; |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 536 | } |
| 537 | } |
| 538 | |
| 539 | SECTION("non-leaf identifiers") |
| 540 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 541 | SECTION("set mod:nonexistent 'blabla'") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 542 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 543 | input = "set mod:nonexistent 'blabla'"; |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 544 | } |
| 545 | |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 546 | SECTION("set mod:contA 'abde'") |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 547 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 548 | input = "set mod:contA 'abde'"; |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 549 | } |
| 550 | } |
| 551 | |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 552 | SECTION("wrong types") |
| 553 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 554 | expectedError = "leaf data type mismatch"; |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 555 | SECTION("set mod:leafBool 'blabla'") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 556 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 557 | input = "set mod:leafBool 'blabla'"; |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 558 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 559 | SECTION("set mod:leafUint8 'blabla'") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 560 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 561 | input = "set mod:leafUint8 'blabla'"; |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 562 | } |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 563 | SECTION("set mod:leafUint8 -5") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 564 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 565 | input = "set mod:leafUint8 -5"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 566 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 567 | SECTION("set mod:leafInt8 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 568 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 569 | input = "set mod:leafInt8 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 570 | } |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 571 | SECTION("set mod:leafInt8 130") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 572 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 573 | input = "set mod:leafInt8 130"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 574 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 575 | SECTION("set mod:leafUint16 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 576 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 577 | input = "set mod:leafUint16 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 578 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 579 | SECTION("set mod:leafInt16 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 580 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 581 | input = "set mod:leafInt16 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 582 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 583 | SECTION("set mod:leafUint32 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 584 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 585 | input = "set mod:leafUint32 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 586 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 587 | SECTION("set mod:leafInt32 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 588 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 589 | input = "set mod:leafInt32 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 590 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 591 | SECTION("set mod:leafUint64 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 592 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 593 | input = "set mod:leafUint64 'blabla'"; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 594 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 595 | SECTION("set mod:leafInt64 'blabla'") |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 596 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 597 | input = "set mod:leafInt64 'blabla'"; |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 598 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 599 | SECTION("set mod:leafEnum 'blabla'") |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 600 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 601 | input = "set mod:leafEnum 'blabla'"; |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 602 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 603 | SECTION("set mod:refToInt8 'blabla'") |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 604 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 605 | input = "set mod:refToInt8 'blabla'"; |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 606 | } |
Václav Kubernát | ebca255 | 2018-06-08 19:06:02 +0200 | [diff] [blame] | 607 | } |
| 608 | |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 609 | SECTION("wrong base64 strings") |
| 610 | { |
| 611 | SECTION("invalid character") |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 612 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 613 | input = "set mod:leafBinary dbahj-"; |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 614 | } |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 615 | SECTION("equal sign in the middle") |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 616 | { |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 617 | input = "set mod:leafBinary db=ahj"; |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 618 | } |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 619 | SECTION("enclosing in quotes") |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 620 | { |
Václav Kubernát | 1bbac7c | 2020-01-15 17:45:41 +0100 | [diff] [blame] | 621 | input = "set mod:leafBinary 'dbahj'"; |
Václav Kubernát | b4e5b18 | 2020-11-16 19:55:09 +0100 | [diff] [blame] | 622 | } |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 623 | } |
| 624 | |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 625 | SECTION("non-existing identity") |
| 626 | { |
| 627 | input = "set mod:foodIdentRef identityBLABLA"; |
| 628 | } |
| 629 | |
Václav Kubernát | f365ecf | 2020-06-09 16:22:43 +0200 | [diff] [blame] | 630 | SECTION("identity with non-existing module") |
| 631 | { |
| 632 | expectedError = "Invalid module name"; |
| 633 | input = "set mod:foodIdentRef xd:haha"; |
| 634 | } |
| 635 | |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 636 | SECTION("setting identities with wrong bases") |
| 637 | { |
| 638 | SECTION("set mod:foodIdentRef mod:vehicle") |
| 639 | { |
| 640 | input = "set mod:foodIdentRef mod:vehicle"; |
| 641 | } |
| 642 | SECTION("set mod:pizzaIdentRef mod:food") |
| 643 | { |
| 644 | input = "set mod:pizzaIdentRef mod:food"; |
| 645 | } |
| 646 | } |
| 647 | SECTION("setting different module identities without prefix") |
| 648 | { |
| 649 | input = "set mod:pizzaIdentRef hawaii"; |
| 650 | } |
| 651 | SECTION("identity prefix without name") |
| 652 | { |
| 653 | input = "set mod:contA/identInCont pizza-module:"; |
| 654 | } |
| 655 | |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 656 | SECTION("set a union path to a wrong type") |
| 657 | { |
| 658 | input = "set mod:intOrString true"; |
| 659 | } |
| 660 | |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 661 | SECTION("no space for empty data") |
| 662 | { |
| 663 | input = "set mod:dummy"; |
| 664 | } |
| 665 | |
Václav Kubernát | 0d42c51 | 2020-05-20 21:18:39 +0200 | [diff] [blame] | 666 | SECTION("empty path") |
| 667 | { |
| 668 | input = "set "; |
| 669 | } |
| 670 | |
Václav Kubernát | abf5280 | 2020-05-19 01:31:17 +0200 | [diff] [blame] | 671 | SECTION("setting readonly data") |
| 672 | { |
| 673 | input = "set mod:readonly 123"; |
| 674 | } |
| 675 | |
Václav Kubernát | dab73ca | 2020-10-26 23:44:43 +0100 | [diff] [blame] | 676 | SECTION("nonexistent bits") |
| 677 | { |
| 678 | input = "set mod:flags daw"; |
| 679 | } |
| 680 | |
| 681 | SECTION("same bit more than once") |
| 682 | { |
| 683 | input = "set mod:flags carry carry"; |
| 684 | } |
| 685 | |
Jan Kundrát | 03c77a1 | 2023-08-28 14:23:05 +0200 | [diff] [blame^] | 686 | parser.changeNode(cwd); |
Jan Kundrát | c381e63 | 2019-03-14 13:39:11 +0100 | [diff] [blame] | 687 | REQUIRE_THROWS_AS(parser.parseCommand(input, errorStream), InvalidCommandException); |
Václav Kubernát | 777704d | 2020-01-15 18:48:06 +0100 | [diff] [blame] | 688 | REQUIRE(errorStream.str().find(expectedError) != std::string::npos); |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 689 | } |
Jan Kundrát | b7206ad | 2020-06-18 21:08:14 +0200 | [diff] [blame] | 690 | |
| 691 | SECTION("deleting a leaf") |
| 692 | { |
| 693 | delete_ expected; |
| 694 | input = "delete mod:leafString"; |
Václav Kubernát | faacd02 | 2020-07-08 16:44:38 +0200 | [diff] [blame] | 695 | expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString")); |
Jan Kundrát | b7206ad | 2020-06-18 21:08:14 +0200 | [diff] [blame] | 696 | |
| 697 | command_ command = parser.parseCommand(input, errorStream); |
| 698 | REQUIRE(command.type() == typeid(delete_)); |
| 699 | REQUIRE(boost::get<delete_>(command) == expected); |
| 700 | } |
Václav Kubernát | 0720424 | 2018-06-04 18:12:09 +0200 | [diff] [blame] | 701 | } |