tests/leaf_editing.cpp - CzechLight/netconf-cli - Gitiles

 /*
  * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
  * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
  *
  * Written by Václav Kubernát <kubervac@fit.cvut.cz>
  *
 */

 #include "trompeloeil_doctest.hpp"
 #include <boost/core/demangle.hpp>
 #include "ast_commands.hpp"
 #include "leaf_data_helpers.hpp"
 #include "parser.hpp"
 #include "pretty_printers.hpp"
 #include "static_schema.hpp"
 #include "utils.hpp"

 TEST_CASE("leaf editing")
 {
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("mod");
     schema->addModule("pizza-module");
     schema->addContainer("/", "mod:contA");
     schema->addLeaf("/", "mod:leafString", yang::String{});
     schema->addLeaf("/", "mod:leafDecimal", yang::Decimal{});
     schema->addLeaf("/", "mod:leafBool", yang::Bool{});
     schema->addLeaf("/", "mod:leafInt8", yang::Int8{});
     schema->addLeaf("/", "mod:leafInt16", yang::Int16{});
     schema->addLeaf("/", "mod:leafInt32", yang::Int32{});
     schema->addLeaf("/", "mod:leafInt64", yang::Int64{});
     schema->addLeaf("/", "mod:leafUint8", yang::Uint8{});
     schema->addLeaf("/", "mod:leafUint16", yang::Uint16{});
     schema->addLeaf("/", "mod:leafUint32", yang::Uint32{});
     schema->addLeaf("/", "mod:leafUint64", yang::Uint64{});
     schema->addLeaf("/", "mod:leafBinary", yang::Binary{});
     schema->addIdentity(std::nullopt, identityRef_{"mod", "food"});
     schema->addIdentity(std::nullopt, identityRef_{"mod", "vehicle"});
     schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "pizza"});
     schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "spaghetti"});
     schema->addIdentity(identityRef_{"mod", "pizza"}, identityRef_{"pizza-module", "hawaii"});
     schema->addLeaf("/", "mod:foodIdentRef", yang::IdentityRef{schema->validIdentities("mod", "food")});
     schema->addLeaf("/", "mod:pizzaIdentRef", yang::IdentityRef{schema->validIdentities("mod", "pizza")});
     schema->addLeaf("/mod:contA", "mod:identInCont", yang::IdentityRef{schema->validIdentities("mod", "pizza")});
     schema->addLeaf("/", "mod:leafEnum", createEnum({"lol", "data", "coze"}));
     schema->addLeaf("/mod:contA", "mod:leafInCont", yang::String{});
     schema->addList("/", "mod:list", {"number"});
     schema->addLeaf("/mod:list", "mod:number", yang::Int32{});
     schema->addLeaf("/mod:list", "mod:leafInList", yang::String{});
     schema->addLeaf("/", "mod:refToString", yang::LeafRef{"/mod:leafString", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafString"))});
     schema->addLeaf("/", "mod:refToInt8", yang::LeafRef{"/mod:leafInt8", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafInt8"))});
     schema->addLeaf("/", "mod:refToLeafInCont", yang::LeafRef{"/mod:contA/identInCont", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:contA/mod:identInCont"))});
     schema->addLeaf("/", "mod:intOrString", yang::Union{{yang::TypeInfo{yang::Int32{}}, yang::TypeInfo{yang::String{}}}});
     schema->addLeaf("/", "mod:twoInts", yang::Union{{yang::TypeInfo{yang::Uint8{}}, yang::TypeInfo{yang::Int16{}}}});
     schema->addLeaf("/", "mod:unionStringEnumLeafref", yang::Union{{
             yang::LeafDataType{yang::String{}},
         yang::LeafDataType{createEnum({"foo", "bar"})},
         yang::LeafDataType{yang::LeafRef{"/mod:leafEnum", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafEnum"))}}
     }});

     schema->addList("/", "mod:portSettings", {"port"});
     schema->addLeaf("/mod:portSettings", "mod:port", createEnum({"eth0", "eth1", "eth2"}));
     schema->addList("/", "mod:portMapping", {"port"});
     schema->addLeaf("/mod:portMapping", "mod:port", createEnum({"utf1", "utf2", "utf3"}));
     schema->addLeaf("/", "mod:activeMappedPort", yang::LeafRef{"/mod:portMapping/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portMapping/mod:port"))});
     schema->addLeaf("/", "mod:activePort", yang::Union{{
         yang::TypeInfo{createEnum({"wlan0", "wlan1"})},
         yang::TypeInfo{yang::LeafRef{"/mod:portSettings/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portSettings/mod:port"))}},
         yang::TypeInfo{yang::LeafRef{"/mod:activeMappedPort", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:activeMappedPort"))}},
         yang::TypeInfo{yang::Empty{}},
     }});
     schema->addLeaf("/", "mod:dummy", yang::Empty{});
     schema->addLeaf("/", "mod:readonly", yang::Int32{}, yang::AccessType::ReadOnly);

     schema->addLeaf("/", "mod:flags", yang::Bits{{"carry", "sign"}});

     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;

     SECTION("valid input")
     {
         set_ expected;

         SECTION("set mod:leafString \"some_data\"")
         {
             input = "set mod:leafString \'some_data\'";
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
             expected.m_data = std::string("some_data");
         }

         SECTION("set mod:contA/leafInCont 'more_data'")
         {
             input = "set mod:contA/leafInCont 'more_data'";
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
             expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
             expected.m_data = std::string("more_data");
         }

         SECTION("set mod:contA/leafInCont \"data with' a quote\"")
         {
             input = "set mod:contA/leafInCont \"data with' a quote\"";
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
             expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
             expected.m_data = std::string("data with' a quote");
         }

         SECTION("set mod:contA/leafInCont 'data with\" a quote'")
         {
             input = "set mod:contA/leafInCont 'data with\" a quote'";
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
             expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
             expected.m_data = std::string("data with\" a quote");
         }

         SECTION("set mod:contA/leafInCont   'more   d\tata'") // spaces in string
         {
             input = "set mod:contA/leafInCont 'more   d\tata'";
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
             expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
             expected.m_data = std::string("more   d\tata");
         }

         SECTION("set mod:list[number=1]/leafInList \"another_data\"")
         {
             input = "set mod:list[number=1]/leafInList \"another_data\"";
             auto keys = ListInstance{
                 {"number", int32_t{1}}};
             expected.m_path.m_nodes.emplace_back(module_{"mod"}, listElement_("list", keys));
             expected.m_path.m_nodes.emplace_back(leaf_("leafInList"));
             expected.m_data = std::string("another_data");
         }

         SECTION("data types")
         {
             SECTION("string")
             {
                 input = "set mod:leafString \"somedata\"";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
                 expected.m_data = std::string("somedata");
             }

             SECTION("more spaces before value")
             {
                 input = "set mod:leafString   \"somedata\"";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
                 expected.m_data = std::string("somedata");
             }

             SECTION("int8")
             {
                 input = "set mod:leafInt8 2";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8"));
                 expected.m_data = int8_t{2};
             }

             SECTION("negative int8")
             {
                 input = "set mod:leafInt8 -10";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8"));
                 expected.m_data = int8_t{-10};
             }

             SECTION("uint8")
             {
                 input = "set mod:leafUint8 2";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint8"));
                 expected.m_data = uint8_t{2};
             }

             SECTION("int16")
             {
                 input = "set mod:leafInt16 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt16"));
                 expected.m_data = int16_t{30'000};
             }

             SECTION("uint16")
             {
                 input = "set mod:leafUint16 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint16"));
                 expected.m_data = uint16_t{30'000};
             }

             SECTION("int32")
             {
                 input = "set mod:leafInt32 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32"));
                 expected.m_data = int32_t{30'000};
             }

             SECTION("uint32")
             {
                 input = "set mod:leafUint32 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint32"));
                 expected.m_data = uint32_t{30'000};
             }

             SECTION("int32")
             {
                 input = "set mod:leafInt32 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32"));
                 expected.m_data = int32_t{30'000};
             }

             SECTION("uint64")
             {
                 input = "set mod:leafUint64 30000";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint64"));
                 expected.m_data = uint64_t{30'000};
             }

             SECTION("decimal")
             {
                 input = "set mod:leafDecimal 3.14159";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafDecimal"));
                 expected.m_data = 3.14159;
             }

             SECTION("enum")
             {
                 input = "set mod:leafEnum coze";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafEnum"));
                 expected.m_data = enum_("coze");
             }

             SECTION("bool")
             {
                 input = "set mod:leafBool true";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBool"));
                 expected.m_data = true;
             }

             SECTION("union")
             {
                 SECTION("int")
                 {
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString"));
                     input = "set mod:intOrString 90";
                     expected.m_data = int32_t{90};
                 }
                 SECTION("string")
                 {
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString"));
                     input = "set mod:intOrString \"test\"";
                     expected.m_data = std::string{"test"};
                 }

                 SECTION("union with two integral types")
                 {
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("twoInts"));
                     SECTION("uint8")
                     {
                         input = "set mod:twoInts 100";
                         expected.m_data = uint8_t{100};
                     }
                     SECTION("int16")
                     {
                         input = "set mod:twoInts 6666";
                         expected.m_data = int16_t{6666};
                     }
                 }

                 SECTION("union with enum and leafref to enum")
                 {
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("unionStringEnumLeafref"));
                     SECTION("string")
                     {
                         input = "set mod:unionStringEnumLeafref \"AHOJ\"";
                         expected.m_data = std::string{"AHOJ"};
                     }
                     SECTION("enum")
                     {
                         input = "set mod:unionStringEnumLeafref bar";
                         expected.m_data = enum_("bar");
                     }
                     SECTION("enum leafref")
                     {
                         input = "set mod:unionStringEnumLeafref coze";
                         expected.m_data = enum_("coze");
                     }
                 }

                 SECTION("activePort")
                 {
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("activePort"));
                     input = "set mod:activePort ";
                     SECTION("1. anonymous enum")
                     {
                         SECTION("wlan0")
                         {
                             input += "wlan0";
                             expected.m_data = enum_("wlan0");
                         }
                         SECTION("wlan1")
                         {
                             input += "wlan1";
                             expected.m_data = enum_("wlan1");
                         }
                     }
                     SECTION("2. leafref to enum")
                     {
                         SECTION("eth0")
                         {
                             input += "eth0";
                             expected.m_data = enum_("eth0");
                         }
                         SECTION("eth1")
                         {
                             input += "eth1";
                             expected.m_data = enum_("eth1");
                         }
                         SECTION("eth2")
                         {
                             input += "eth2";
                             expected.m_data = enum_("eth2");
                         }
                     }
                     SECTION("3. leafref to leafref")
                     {
                         SECTION("utf1")
                         {
                             input += "utf1";
                             expected.m_data = enum_("utf1");
                         }
                         SECTION("utf2")
                         {
                             input += "utf2";
                             expected.m_data = enum_("utf2");
                         }
                         SECTION("utf3")
                         {
                             input += "utf3";
                             expected.m_data = enum_("utf3");
                         }
                     }
                     SECTION("4. empty")
                     {
                         expected.m_data = empty_{};
                     }
                 }
             }

             SECTION("binary")
             {
                 SECTION("zero ending '='")
                 {
                     input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++";
                     expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++"};
                 }

                 SECTION("one ending '='")
                 {
                     input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++=";
                     expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++="};
                 }

                 SECTION("two ending '='")
                 {
                     input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++==";
                     expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++=="};
                 }
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBinary"));
             }

             SECTION("identityRef")
             {
                 SECTION("foodIdentRef")
                 {
                     input = "set mod:foodIdentRef ";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("foodIdentRef"));

                     SECTION("food")
                     {
                         input += "food";
                         expected.m_data = identityRef_("food");
                     }
                     SECTION("mod:food")
                     {
                         input += "mod:food";
                         expected.m_data = identityRef_("mod", "food");
                     }
                     SECTION("pizza")
                     {
                         input += "pizza";
                         expected.m_data = identityRef_("pizza");
                     }
                     SECTION("mod:pizza")
                     {
                         input += "mod:pizza";
                         expected.m_data = identityRef_("mod", "pizza");
                     }
                     SECTION("pizza-module:hawaii")
                     {
                         input += "pizza-module:hawaii";
                         expected.m_data = identityRef_("pizza-module", "hawaii");
                     }
                 }
                 SECTION("pizzaIdentRef")
                 {
                     input = "set mod:pizzaIdentRef ";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("pizzaIdentRef"));
                     SECTION("pizza")
                     {
                         input += "pizza";
                         expected.m_data = identityRef_("pizza");
                     }
                     SECTION("mod:pizza")
                     {
                         input += "mod:pizza";
                         expected.m_data = identityRef_("mod", "pizza");
                     }
                     SECTION("pizza-module:hawaii")
                     {
                         input += "pizza-module:hawaii";
                         expected.m_data = identityRef_("pizza-module", "hawaii");
                     }
                 }
                 SECTION("mod:contA/identInCont")
                 {
                     input = "set mod:contA/identInCont ";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
                     expected.m_path.m_nodes.emplace_back(leaf_("identInCont"));
                     SECTION("pizza")
                     {
                         input += "pizza";
                         expected.m_data = identityRef_("pizza");
                     }
                     SECTION("mod:pizza")
                     {
                         input += "mod:pizza";
                         expected.m_data = identityRef_("mod", "pizza");
                     }
                     SECTION("pizza-module:hawaii")
                     {
                         input += "pizza-module:hawaii";
                         expected.m_data = identityRef_("pizza-module", "hawaii");
                     }
                 }
             }
             SECTION("leafRef")
             {
                 SECTION("refToString")
                 {
                     input = "set mod:refToString \"blabal\"";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToString"));
                     expected.m_data = std::string("blabal");
                 }

                 SECTION("refToInt8")
                 {
                     input = "set mod:refToInt8 42";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToInt8"));
                     expected.m_data = int8_t{42};
                 }

                 SECTION("refToLeafInCont")
                 {
                     input = "set mod:refToLeafInCont pizza";
                     expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToLeafInCont"));
                     expected.m_data = identityRef_{"pizza"};
                 }
             }
             SECTION("empty")
             {
                 input = "set mod:dummy ";
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("dummy"));
                 expected.m_data = empty_{};
             }

             SECTION("bits")
             {
                 input = "set mod:flags ";
                 decltype(bits_::m_bits) bits;
                 SECTION("<nothing>")
                 {
                     bits = {};
                 }
                 SECTION("carry")
                 {
                     input += "carry";
                     bits = {"carry"};
                 }
                 SECTION("sign")
                 {
                     input += "sign";
                     bits = {"sign"};
                 }
                 SECTION("carry sign")
                 {
                     input += "carry sign";
                     bits = {"carry", "sign"};
                 }
                 SECTION("sign carry")
                 {
                     input += "sign carry";
                     bits = {"sign", "carry"};
                 }
                 expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("flags"));
                 expected.m_data = bits_{bits};
             }
         }

         command_ command = parser.parseCommand(input, errorStream);
         REQUIRE(command.type() == typeid(set_));
         REQUIRE(boost::get<set_>(command) == expected);
     }

     SECTION("invalid input")
     {
         std::string expectedError;
         SECTION("missing space between a command and its arguments")
         {
             SECTION("setmod:leafString some_data")
             {
                 input = "setmod:leafString 'some_data'";
             }
         }

         SECTION("missing space between arguments")
         {
             SECTION("set mod:leafString'lol'")
             {
                 input = "set mod:leafString'lol'";
             }
         }

         SECTION("non-leaf identifiers")
         {
             SECTION("set mod:nonexistent 'blabla'")
             {
                 input = "set mod:nonexistent 'blabla'";
             }

             SECTION("set mod:contA 'abde'")
             {
                 input = "set mod:contA 'abde'";
             }
         }

         SECTION("wrong types")
         {
             expectedError = "leaf data type mismatch";
             SECTION("set mod:leafBool 'blabla'")
             {
                 input = "set mod:leafBool 'blabla'";
             }
             SECTION("set mod:leafUint8 'blabla'")
             {
                 input = "set mod:leafUint8 'blabla'";
             }
             SECTION("set mod:leafUint8 -5")
             {
                 input = "set mod:leafUint8 -5";
             }
             SECTION("set mod:leafInt8 'blabla'")
             {
                 input = "set mod:leafInt8 'blabla'";
             }
             SECTION("set mod:leafInt8 130")
             {
                 input = "set mod:leafInt8 130";
             }
             SECTION("set mod:leafUint16 'blabla'")
             {
                 input = "set mod:leafUint16 'blabla'";
             }
             SECTION("set mod:leafInt16 'blabla'")
             {
                 input = "set mod:leafInt16 'blabla'";
             }
             SECTION("set mod:leafUint32 'blabla'")
             {
                 input = "set mod:leafUint32 'blabla'";
             }
             SECTION("set mod:leafInt32 'blabla'")
             {
                 input = "set mod:leafInt32 'blabla'";
             }
             SECTION("set mod:leafUint64 'blabla'")
             {
                 input = "set mod:leafUint64 'blabla'";
             }
             SECTION("set mod:leafInt64 'blabla'")
             {
                 input = "set mod:leafInt64 'blabla'";
             }
             SECTION("set mod:leafEnum 'blabla'")
             {
                 input = "set mod:leafEnum 'blabla'";
             }
             SECTION("set mod:refToInt8 'blabla'")
             {
                 input = "set mod:refToInt8 'blabla'";
             }
         }

         SECTION("wrong base64 strings")
         {
             SECTION("invalid character")
             {
                 input = "set mod:leafBinary dbahj-";
             }
             SECTION("equal sign in the middle")
             {
                 input = "set mod:leafBinary db=ahj";
             }
             SECTION("enclosing in quotes")
             {
                 input = "set mod:leafBinary 'dbahj'";
             }
         }

         SECTION("non-existing identity")
         {
             input = "set mod:foodIdentRef identityBLABLA";
         }

         SECTION("identity with non-existing module")
         {
             expectedError = "Invalid module name";
             input = "set mod:foodIdentRef xd:haha";
         }

         SECTION("setting identities with wrong bases")
         {
             SECTION("set mod:foodIdentRef mod:vehicle")
             {
                 input = "set mod:foodIdentRef mod:vehicle";
             }
             SECTION("set mod:pizzaIdentRef mod:food")
             {
                 input = "set mod:pizzaIdentRef mod:food";
             }
         }
         SECTION("setting different module identities without prefix")
         {
             input = "set mod:pizzaIdentRef hawaii";
         }
         SECTION("identity prefix without name")
         {
             input = "set mod:contA/identInCont pizza-module:";
         }

         SECTION("set a union path to a wrong type")
         {
             input = "set mod:intOrString true";
         }

         SECTION("no space for empty data")
         {
             input = "set mod:dummy";
         }

         SECTION("empty path")
         {
             input = "set ";
         }

         SECTION("setting readonly data")
         {
             input = "set mod:readonly 123";
         }

         SECTION("nonexistent bits")
         {
             input = "set mod:flags daw";
         }

         SECTION("same bit more than once")
         {
             input = "set mod:flags carry carry";
         }

         REQUIRE_THROWS_AS(parser.parseCommand(input, errorStream), InvalidCommandException);
         REQUIRE(errorStream.str().find(expectedError) != std::string::npos);
     }

     SECTION("deleting a leaf")
     {
         delete_ expected;
         input = "delete mod:leafString";
         expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));

         command_ command = parser.parseCommand(input, errorStream);
         REQUIRE(command.type() == typeid(delete_));
         REQUIRE(boost::get<delete_>(command) == expected);
     }
 }
	/*
	* Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
	* Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
	*
	* Written by Václav Kubernát <kubervac@fit.cvut.cz>
	*
	*/

	#include "trompeloeil_doctest.hpp"
	#include <boost/core/demangle.hpp>
	#include "ast_commands.hpp"
	#include "leaf_data_helpers.hpp"
	#include "parser.hpp"
	#include "pretty_printers.hpp"
	#include "static_schema.hpp"
	#include "utils.hpp"

	TEST_CASE("leaf editing")
	{
	auto schema = std::make_shared<StaticSchema>();
	schema->addModule("mod");
	schema->addModule("pizza-module");
	schema->addContainer("/", "mod:contA");
	schema->addLeaf("/", "mod:leafString", yang::String{});
	schema->addLeaf("/", "mod:leafDecimal", yang::Decimal{});
	schema->addLeaf("/", "mod:leafBool", yang::Bool{});
	schema->addLeaf("/", "mod:leafInt8", yang::Int8{});
	schema->addLeaf("/", "mod:leafInt16", yang::Int16{});
	schema->addLeaf("/", "mod:leafInt32", yang::Int32{});
	schema->addLeaf("/", "mod:leafInt64", yang::Int64{});
	schema->addLeaf("/", "mod:leafUint8", yang::Uint8{});
	schema->addLeaf("/", "mod:leafUint16", yang::Uint16{});
	schema->addLeaf("/", "mod:leafUint32", yang::Uint32{});
	schema->addLeaf("/", "mod:leafUint64", yang::Uint64{});
	schema->addLeaf("/", "mod:leafBinary", yang::Binary{});
	schema->addIdentity(std::nullopt, identityRef_{"mod", "food"});
	schema->addIdentity(std::nullopt, identityRef_{"mod", "vehicle"});
	schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "pizza"});
	schema->addIdentity(identityRef_{"mod", "food"}, identityRef_{"mod", "spaghetti"});
	schema->addIdentity(identityRef_{"mod", "pizza"}, identityRef_{"pizza-module", "hawaii"});
	schema->addLeaf("/", "mod:foodIdentRef", yang::IdentityRef{schema->validIdentities("mod", "food")});
	schema->addLeaf("/", "mod:pizzaIdentRef", yang::IdentityRef{schema->validIdentities("mod", "pizza")});
	schema->addLeaf("/mod:contA", "mod:identInCont", yang::IdentityRef{schema->validIdentities("mod", "pizza")});
	schema->addLeaf("/", "mod:leafEnum", createEnum({"lol", "data", "coze"}));
	schema->addLeaf("/mod:contA", "mod:leafInCont", yang::String{});
	schema->addList("/", "mod:list", {"number"});
	schema->addLeaf("/mod:list", "mod:number", yang::Int32{});
	schema->addLeaf("/mod:list", "mod:leafInList", yang::String{});
	schema->addLeaf("/", "mod:refToString", yang::LeafRef{"/mod:leafString", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafString"))});
	schema->addLeaf("/", "mod:refToInt8", yang::LeafRef{"/mod:leafInt8", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafInt8"))});
	schema->addLeaf("/", "mod:refToLeafInCont", yang::LeafRef{"/mod:contA/identInCont", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:contA/mod:identInCont"))});
	schema->addLeaf("/", "mod:intOrString", yang::Union{{yang::TypeInfo{yang::Int32{}}, yang::TypeInfo{yang::String{}}}});
	schema->addLeaf("/", "mod:twoInts", yang::Union{{yang::TypeInfo{yang::Uint8{}}, yang::TypeInfo{yang::Int16{}}}});
	schema->addLeaf("/", "mod:unionStringEnumLeafref", yang::Union{{
	yang::LeafDataType{yang::String{}},
	yang::LeafDataType{createEnum({"foo", "bar"})},
	yang::LeafDataType{yang::LeafRef{"/mod:leafEnum", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:leafEnum"))}}
	}});

	schema->addList("/", "mod:portSettings", {"port"});
	schema->addLeaf("/mod:portSettings", "mod:port", createEnum({"eth0", "eth1", "eth2"}));
	schema->addList("/", "mod:portMapping", {"port"});
	schema->addLeaf("/mod:portMapping", "mod:port", createEnum({"utf1", "utf2", "utf3"}));
	schema->addLeaf("/", "mod:activeMappedPort", yang::LeafRef{"/mod:portMapping/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portMapping/mod:port"))});
	schema->addLeaf("/", "mod:activePort", yang::Union{{
	yang::TypeInfo{createEnum({"wlan0", "wlan1"})},
	yang::TypeInfo{yang::LeafRef{"/mod:portSettings/mod:port", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:portSettings/mod:port"))}},
	yang::TypeInfo{yang::LeafRef{"/mod:activeMappedPort", std::make_unique<yang::TypeInfo>(schema->leafType("/mod:activeMappedPort"))}},
	yang::TypeInfo{yang::Empty{}},
	}});
	schema->addLeaf("/", "mod:dummy", yang::Empty{});
	schema->addLeaf("/", "mod:readonly", yang::Int32{}, yang::AccessType::ReadOnly);

	schema->addLeaf("/", "mod:flags", yang::Bits{{"carry", "sign"}});

	Parser parser(schema);
	std::string input;
	std::ostringstream errorStream;

	SECTION("valid input")
	{
	set_ expected;

	SECTION("set mod:leafString \"some_data\"")
	{
	input = "set mod:leafString \'some_data\'";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
	expected.m_data = std::string("some_data");
	}

	SECTION("set mod:contA/leafInCont 'more_data'")
	{
	input = "set mod:contA/leafInCont 'more_data'";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
	expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
	expected.m_data = std::string("more_data");
	}

	SECTION("set mod:contA/leafInCont \"data with' a quote\"")
	{
	input = "set mod:contA/leafInCont \"data with' a quote\"";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
	expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
	expected.m_data = std::string("data with' a quote");
	}

	SECTION("set mod:contA/leafInCont 'data with\" a quote'")
	{
	input = "set mod:contA/leafInCont 'data with\" a quote'";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
	expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
	expected.m_data = std::string("data with\" a quote");
	}

	SECTION("set mod:contA/leafInCont 'more d\tata'") // spaces in string
	{
	input = "set mod:contA/leafInCont 'more d\tata'";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
	expected.m_path.m_nodes.emplace_back(leaf_("leafInCont"));
	expected.m_data = std::string("more d\tata");
	}

	SECTION("set mod:list[number=1]/leafInList \"another_data\"")
	{
	input = "set mod:list[number=1]/leafInList \"another_data\"";
	auto keys = ListInstance{
	{"number", int32_t{1}}};
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, listElement_("list", keys));
	expected.m_path.m_nodes.emplace_back(leaf_("leafInList"));
	expected.m_data = std::string("another_data");
	}

	SECTION("data types")
	{
	SECTION("string")
	{
	input = "set mod:leafString \"somedata\"";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
	expected.m_data = std::string("somedata");
	}

	SECTION("more spaces before value")
	{
	input = "set mod:leafString \"somedata\"";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));
	expected.m_data = std::string("somedata");
	}

	SECTION("int8")
	{
	input = "set mod:leafInt8 2";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8"));
	expected.m_data = int8_t{2};
	}

	SECTION("negative int8")
	{
	input = "set mod:leafInt8 -10";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt8"));
	expected.m_data = int8_t{-10};
	}

	SECTION("uint8")
	{
	input = "set mod:leafUint8 2";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint8"));
	expected.m_data = uint8_t{2};
	}

	SECTION("int16")
	{
	input = "set mod:leafInt16 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt16"));
	expected.m_data = int16_t{30'000};
	}

	SECTION("uint16")
	{
	input = "set mod:leafUint16 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint16"));
	expected.m_data = uint16_t{30'000};
	}

	SECTION("int32")
	{
	input = "set mod:leafInt32 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32"));
	expected.m_data = int32_t{30'000};
	}

	SECTION("uint32")
	{
	input = "set mod:leafUint32 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint32"));
	expected.m_data = uint32_t{30'000};
	}

	SECTION("int32")
	{
	input = "set mod:leafInt32 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafInt32"));
	expected.m_data = int32_t{30'000};
	}

	SECTION("uint64")
	{
	input = "set mod:leafUint64 30000";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafUint64"));
	expected.m_data = uint64_t{30'000};
	}

	SECTION("decimal")
	{
	input = "set mod:leafDecimal 3.14159";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafDecimal"));
	expected.m_data = 3.14159;
	}

	SECTION("enum")
	{
	input = "set mod:leafEnum coze";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafEnum"));
	expected.m_data = enum_("coze");
	}

	SECTION("bool")
	{
	input = "set mod:leafBool true";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBool"));
	expected.m_data = true;
	}

	SECTION("union")
	{
	SECTION("int")
	{
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString"));
	input = "set mod:intOrString 90";
	expected.m_data = int32_t{90};
	}
	SECTION("string")
	{
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("intOrString"));
	input = "set mod:intOrString \"test\"";
	expected.m_data = std::string{"test"};
	}

	SECTION("union with two integral types")
	{
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("twoInts"));
	SECTION("uint8")
	{
	input = "set mod:twoInts 100";
	expected.m_data = uint8_t{100};
	}
	SECTION("int16")
	{
	input = "set mod:twoInts 6666";
	expected.m_data = int16_t{6666};
	}
	}

	SECTION("union with enum and leafref to enum")
	{
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("unionStringEnumLeafref"));
	SECTION("string")
	{
	input = "set mod:unionStringEnumLeafref \"AHOJ\"";
	expected.m_data = std::string{"AHOJ"};
	}
	SECTION("enum")
	{
	input = "set mod:unionStringEnumLeafref bar";
	expected.m_data = enum_("bar");
	}
	SECTION("enum leafref")
	{
	input = "set mod:unionStringEnumLeafref coze";
	expected.m_data = enum_("coze");
	}
	}

	SECTION("activePort")
	{
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("activePort"));
	input = "set mod:activePort ";
	SECTION("1. anonymous enum")
	{
	SECTION("wlan0")
	{
	input += "wlan0";
	expected.m_data = enum_("wlan0");
	}
	SECTION("wlan1")
	{
	input += "wlan1";
	expected.m_data = enum_("wlan1");
	}
	}
	SECTION("2. leafref to enum")
	{
	SECTION("eth0")
	{
	input += "eth0";
	expected.m_data = enum_("eth0");
	}
	SECTION("eth1")
	{
	input += "eth1";
	expected.m_data = enum_("eth1");
	}
	SECTION("eth2")
	{
	input += "eth2";
	expected.m_data = enum_("eth2");
	}
	}
	SECTION("3. leafref to leafref")
	{
	SECTION("utf1")
	{
	input += "utf1";
	expected.m_data = enum_("utf1");
	}
	SECTION("utf2")
	{
	input += "utf2";
	expected.m_data = enum_("utf2");
	}
	SECTION("utf3")
	{
	input += "utf3";
	expected.m_data = enum_("utf3");
	}
	}
	SECTION("4. empty")
	{
	expected.m_data = empty_{};
	}
	}
	}

	SECTION("binary")
	{
	SECTION("zero ending '='")
	{
	input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++";
	expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++"};
	}

	SECTION("one ending '='")
	{
	input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++=";
	expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++="};
	}

	SECTION("two ending '='")
	{
	input = "set mod:leafBinary This/IsABase64EncodedSomething++/342431++==";
	expected.m_data = binary_{"This/IsABase64EncodedSomething++/342431++=="};
	}
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafBinary"));
	}

	SECTION("identityRef")
	{
	SECTION("foodIdentRef")
	{
	input = "set mod:foodIdentRef ";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("foodIdentRef"));

	SECTION("food")
	{
	input += "food";
	expected.m_data = identityRef_("food");
	}
	SECTION("mod:food")
	{
	input += "mod:food";
	expected.m_data = identityRef_("mod", "food");
	}
	SECTION("pizza")
	{
	input += "pizza";
	expected.m_data = identityRef_("pizza");
	}
	SECTION("mod:pizza")
	{
	input += "mod:pizza";
	expected.m_data = identityRef_("mod", "pizza");
	}
	SECTION("pizza-module:hawaii")
	{
	input += "pizza-module:hawaii";
	expected.m_data = identityRef_("pizza-module", "hawaii");
	}
	}
	SECTION("pizzaIdentRef")
	{
	input = "set mod:pizzaIdentRef ";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("pizzaIdentRef"));
	SECTION("pizza")
	{
	input += "pizza";
	expected.m_data = identityRef_("pizza");
	}
	SECTION("mod:pizza")
	{
	input += "mod:pizza";
	expected.m_data = identityRef_("mod", "pizza");
	}
	SECTION("pizza-module:hawaii")
	{
	input += "pizza-module:hawaii";
	expected.m_data = identityRef_("pizza-module", "hawaii");
	}
	}
	SECTION("mod:contA/identInCont")
	{
	input = "set mod:contA/identInCont ";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_("contA"));
	expected.m_path.m_nodes.emplace_back(leaf_("identInCont"));
	SECTION("pizza")
	{
	input += "pizza";
	expected.m_data = identityRef_("pizza");
	}
	SECTION("mod:pizza")
	{
	input += "mod:pizza";
	expected.m_data = identityRef_("mod", "pizza");
	}
	SECTION("pizza-module:hawaii")
	{
	input += "pizza-module:hawaii";
	expected.m_data = identityRef_("pizza-module", "hawaii");
	}
	}
	}
	SECTION("leafRef")
	{
	SECTION("refToString")
	{
	input = "set mod:refToString \"blabal\"";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToString"));
	expected.m_data = std::string("blabal");
	}

	SECTION("refToInt8")
	{
	input = "set mod:refToInt8 42";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToInt8"));
	expected.m_data = int8_t{42};
	}

	SECTION("refToLeafInCont")
	{
	input = "set mod:refToLeafInCont pizza";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("refToLeafInCont"));
	expected.m_data = identityRef_{"pizza"};
	}
	}
	SECTION("empty")
	{
	input = "set mod:dummy ";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("dummy"));
	expected.m_data = empty_{};
	}

	SECTION("bits")
	{
	input = "set mod:flags ";
	decltype(bits_::m_bits) bits;
	SECTION("<nothing>")
	{
	bits = {};
	}
	SECTION("carry")
	{
	input += "carry";
	bits = {"carry"};
	}
	SECTION("sign")
	{
	input += "sign";
	bits = {"sign"};
	}
	SECTION("carry sign")
	{
	input += "carry sign";
	bits = {"carry", "sign"};
	}
	SECTION("sign carry")
	{
	input += "sign carry";
	bits = {"sign", "carry"};
	}
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("flags"));
	expected.m_data = bits_{bits};
	}
	}

	command_ command = parser.parseCommand(input, errorStream);
	REQUIRE(command.type() == typeid(set_));
	REQUIRE(boost::get<set_>(command) == expected);
	}

	SECTION("invalid input")
	{
	std::string expectedError;
	SECTION("missing space between a command and its arguments")
	{
	SECTION("setmod:leafString some_data")
	{
	input = "setmod:leafString 'some_data'";
	}
	}

	SECTION("missing space between arguments")
	{
	SECTION("set mod:leafString'lol'")
	{
	input = "set mod:leafString'lol'";
	}
	}

	SECTION("non-leaf identifiers")
	{
	SECTION("set mod:nonexistent 'blabla'")
	{
	input = "set mod:nonexistent 'blabla'";
	}

	SECTION("set mod:contA 'abde'")
	{
	input = "set mod:contA 'abde'";
	}
	}

	SECTION("wrong types")
	{
	expectedError = "leaf data type mismatch";
	SECTION("set mod:leafBool 'blabla'")
	{
	input = "set mod:leafBool 'blabla'";
	}
	SECTION("set mod:leafUint8 'blabla'")
	{
	input = "set mod:leafUint8 'blabla'";
	}
	SECTION("set mod:leafUint8 -5")
	{
	input = "set mod:leafUint8 -5";
	}
	SECTION("set mod:leafInt8 'blabla'")
	{
	input = "set mod:leafInt8 'blabla'";
	}
	SECTION("set mod:leafInt8 130")
	{
	input = "set mod:leafInt8 130";
	}
	SECTION("set mod:leafUint16 'blabla'")
	{
	input = "set mod:leafUint16 'blabla'";
	}
	SECTION("set mod:leafInt16 'blabla'")
	{
	input = "set mod:leafInt16 'blabla'";
	}
	SECTION("set mod:leafUint32 'blabla'")
	{
	input = "set mod:leafUint32 'blabla'";
	}
	SECTION("set mod:leafInt32 'blabla'")
	{
	input = "set mod:leafInt32 'blabla'";
	}
	SECTION("set mod:leafUint64 'blabla'")
	{
	input = "set mod:leafUint64 'blabla'";
	}
	SECTION("set mod:leafInt64 'blabla'")
	{
	input = "set mod:leafInt64 'blabla'";
	}
	SECTION("set mod:leafEnum 'blabla'")
	{
	input = "set mod:leafEnum 'blabla'";
	}
	SECTION("set mod:refToInt8 'blabla'")
	{
	input = "set mod:refToInt8 'blabla'";
	}
	}

	SECTION("wrong base64 strings")
	{
	SECTION("invalid character")
	{
	input = "set mod:leafBinary dbahj-";
	}
	SECTION("equal sign in the middle")
	{
	input = "set mod:leafBinary db=ahj";
	}
	SECTION("enclosing in quotes")
	{
	input = "set mod:leafBinary 'dbahj'";
	}
	}

	SECTION("non-existing identity")
	{
	input = "set mod:foodIdentRef identityBLABLA";
	}

	SECTION("identity with non-existing module")
	{
	expectedError = "Invalid module name";
	input = "set mod:foodIdentRef xd:haha";
	}

	SECTION("setting identities with wrong bases")
	{
	SECTION("set mod:foodIdentRef mod:vehicle")
	{
	input = "set mod:foodIdentRef mod:vehicle";
	}
	SECTION("set mod:pizzaIdentRef mod:food")
	{
	input = "set mod:pizzaIdentRef mod:food";
	}
	}
	SECTION("setting different module identities without prefix")
	{
	input = "set mod:pizzaIdentRef hawaii";
	}
	SECTION("identity prefix without name")
	{
	input = "set mod:contA/identInCont pizza-module:";
	}

	SECTION("set a union path to a wrong type")
	{
	input = "set mod:intOrString true";
	}

	SECTION("no space for empty data")
	{
	input = "set mod:dummy";
	}

	SECTION("empty path")
	{
	input = "set ";
	}

	SECTION("setting readonly data")
	{
	input = "set mod:readonly 123";
	}

	SECTION("nonexistent bits")
	{
	input = "set mod:flags daw";
	}

	SECTION("same bit more than once")
	{
	input = "set mod:flags carry carry";
	}

	REQUIRE_THROWS_AS(parser.parseCommand(input, errorStream), InvalidCommandException);
	REQUIRE(errorStream.str().find(expectedError) != std::string::npos);
	}

	SECTION("deleting a leaf")
	{
	delete_ expected;
	input = "delete mod:leafString";
	expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_("leafString"));

	command_ command = parser.parseCommand(input, errorStream);
	REQUIRE(command.type() == typeid(delete_));
	REQUIRE(boost::get<delete_>(command) == expected);
	}
	}