diff --git a/src/ast_path.cpp b/src/ast_path.cpp
index 3a486a5..bdb3447 100644
--- a/src/ast_path.cpp
+++ b/src/ast_path.cpp
@@ -158,58 +158,42 @@
     return boost::apply_visitor(nodeToSchemaStringVisitor(), node.m_suffix);
 }
 
-std::string pathToDataString(const dataPath_& path)
+std::string pathToDataString(const dataPath_& path, Prefixes prefixes)
 {
     std::string res;
     if (path.m_scope == Scope::Absolute) {
         res = "/";
     }
-    for (const auto it : path.m_nodes)
+
+    for (const auto it : path.m_nodes) {
         if (it.m_prefix)
             res = joinPaths(res, it.m_prefix.value().m_name + ":" + boost::apply_visitor(nodeToDataStringVisitor(), it.m_suffix));
         else
-            res = joinPaths(res, boost::apply_visitor(nodeToDataStringVisitor(), it.m_suffix));
+            res = joinPaths(res, (prefixes == Prefixes::Always ? path.m_nodes.at(0).m_prefix.value().m_name + ":" : "") + boost::apply_visitor(nodeToDataStringVisitor(), it.m_suffix));
+    }
 
     return res;
 }
 
-std::string pathToAbsoluteSchemaString(const dataPath_& path)
-{
-    return pathToAbsoluteSchemaString(dataPathToSchemaPath(path));
-}
-
-std::string pathToAbsoluteSchemaString(const schemaPath_& path)
+std::string pathToSchemaString(const schemaPath_& path, Prefixes prefixes)
 {
     std::string res;
-    if (path.m_nodes.empty()) {
-        return "";
+    if (path.m_scope == Scope::Absolute) {
+        res = "/";
     }
 
-    auto topLevelModule = path.m_nodes.at(0).m_prefix.value();
     for (const auto it : path.m_nodes) {
         if (it.m_prefix)
             res = joinPaths(res, it.m_prefix.value().m_name + ":" + boost::apply_visitor(nodeToSchemaStringVisitor(), it.m_suffix));
         else
-            res = joinPaths(res, topLevelModule.m_name + ":" + boost::apply_visitor(nodeToSchemaStringVisitor(), it.m_suffix));
+            res = joinPaths(res, (prefixes == Prefixes::Always ? path.m_nodes.at(0).m_prefix.value().m_name + ":" : "") + boost::apply_visitor(nodeToSchemaStringVisitor(), it.m_suffix));
     }
     return res;
 }
 
-std::string pathToSchemaString(const schemaPath_& path)
+std::string pathToSchemaString(const dataPath_& path, Prefixes prefixes)
 {
-    std::string res;
-    for (const auto it : path.m_nodes) {
-        if (it.m_prefix)
-            res = joinPaths(res, it.m_prefix.value().m_name + ":" + boost::apply_visitor(nodeToSchemaStringVisitor(), it.m_suffix));
-        else
-            res = joinPaths(res, boost::apply_visitor(nodeToSchemaStringVisitor(), it.m_suffix));
-    }
-    return res;
-}
-
-std::string pathToSchemaString(const dataPath_& path)
-{
-    return pathToSchemaString(dataPathToSchemaPath(path));
+    return pathToSchemaString(dataPathToSchemaPath(path), prefixes);
 }
 
 struct dataSuffixToSchemaSuffix : boost::static_visitor<decltype(schemaNode_::m_suffix)> {
diff --git a/src/ast_path.hpp b/src/ast_path.hpp
index c15351f..338c766 100644
--- a/src/ast_path.hpp
+++ b/src/ast_path.hpp
@@ -16,6 +16,11 @@
 
 #include "ast_values.hpp"
 
+enum class Prefixes {
+    Always,
+    WhenNeeded
+};
+
 struct nodeup_ {
     bool operator==(const nodeup_&) const
     {
@@ -106,10 +111,9 @@
 
 std::string nodeToSchemaString(decltype(dataPath_::m_nodes)::value_type node);
 
-std::string pathToAbsoluteSchemaString(const dataPath_& path);
-std::string pathToAbsoluteSchemaString(const schemaPath_& path);
-std::string pathToDataString(const dataPath_& path);
-std::string pathToSchemaString(const schemaPath_& path);
+std::string pathToDataString(const dataPath_& path, Prefixes prefixes);
+std::string pathToSchemaString(const schemaPath_& path, Prefixes prefixes);
+std::string pathToSchemaString(const dataPath_& path, Prefixes prefixes);
 schemaNode_ dataNodeToSchemaNode(const dataNode_& node);
 schemaPath_ dataPathToSchemaPath(const dataPath_& path);
 std::string escapeListKeyString(const std::string& what);
diff --git a/src/interpreter.cpp b/src/interpreter.cpp
index 61604bb..f112b52 100644
--- a/src/interpreter.cpp
+++ b/src/interpreter.cpp
@@ -109,19 +109,19 @@
 std::string Interpreter::absolutePathFromCommand(const T& command) const
 {
     if (command.m_path.m_scope == Scope::Absolute)
-        return pathToDataString(command.m_path);
+        return pathToDataString(command.m_path, Prefixes::WhenNeeded);
     else
-        return joinPaths(m_parser.currentNode(), pathToDataString(command.m_path));
+        return joinPaths(m_parser.currentNode(), pathToDataString(command.m_path, Prefixes::WhenNeeded));
 }
 
 struct pathToStringVisitor : boost::static_visitor<std::string> {
     std::string operator()(const schemaPath_& path) const
     {
-        return pathToSchemaString(path);
+        return pathToSchemaString(path, Prefixes::WhenNeeded);
     }
     std::string operator()(const dataPath_& path) const
     {
-        return pathToDataString(path);
+        return pathToDataString(path, Prefixes::WhenNeeded);
     }
 };
 
diff --git a/src/parser.cpp b/src/parser.cpp
index c7644e2..ce6ea01 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -80,7 +80,7 @@
 
 std::string Parser::currentNode() const
 {
-    return pathToDataString(m_curDir);
+    return pathToDataString(m_curDir, Prefixes::WhenNeeded);
 }
 
 struct getSchemaPathVisitor : boost::static_visitor<schemaPath_> {
diff --git a/src/schema.hpp b/src/schema.hpp
index b8d74a8..8b7031a 100644
--- a/src/schema.hpp
+++ b/src/schema.hpp
@@ -42,11 +42,6 @@
     Recursive
 };
 
-enum class Prefixes {
-    Always,
-    WhenNeeded
-};
-
 
 class InvalidNodeException : public std::invalid_argument {
 public:
diff --git a/src/static_schema.cpp b/src/static_schema.cpp
index ad2025c..47e0884 100644
--- a/src/static_schema.cpp
+++ b/src/static_schema.cpp
@@ -14,7 +14,7 @@
 
 StaticSchema::StaticSchema()
 {
-    m_nodes.emplace("", std::unordered_map<std::string, NodeType>());
+    m_nodes.emplace("/", std::unordered_map<std::string, NodeType>());
 }
 
 const std::unordered_map<std::string, NodeType>& StaticSchema::children(const std::string& name) const
@@ -38,7 +38,7 @@
 
 bool StaticSchema::isContainer(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     auto fullName = fullNodeName(location, node);
     if (!nodeExists(locationString, fullName))
         return false;
@@ -57,7 +57,7 @@
 
 bool StaticSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     assert(isList(location, node));
 
     const auto& child = children(locationString).at(fullNodeName(location, node));
@@ -67,7 +67,7 @@
 
 const std::set<std::string> StaticSchema::listKeys(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     assert(isList(location, node));
 
     const auto& child = children(locationString).at(fullNodeName(location, node));
@@ -77,7 +77,7 @@
 
 bool StaticSchema::isList(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     auto fullName = fullNodeName(location, node);
     if (!nodeExists(locationString, fullName))
         return false;
@@ -100,7 +100,7 @@
 {
     if (!isContainer(location, node))
         return false;
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     return boost::get<yang::container>(children(locationString).at(fullNodeName(location, node))).m_presence == yang::ContainerTraits::Presence;
 }
 
@@ -172,7 +172,7 @@
 
 const std::set<std::string> StaticSchema::validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     assert(isLeaf(location, node));
 
     const auto& child = children(locationString).at(fullNodeName(location, node));
@@ -207,7 +207,7 @@
 
 bool StaticSchema::isLeaf(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     auto fullName = fullNodeName(location, node);
     if (!nodeExists(locationString, fullName))
         return false;
@@ -219,14 +219,22 @@
 {
     std::string res = path;
     auto pos = res.find_last_of('/');
-    if (pos != res.npos)
+    if (pos == 0) { // path had only one path fragment - "/something:something"
+        res.erase(0, 1);
+        return res;
+    }
+    if (pos != res.npos) { // path had more fragments
         res.erase(0, pos);
+        return res;
+    }
+
+    // path was empty
     return res;
 }
 
 yang::LeafDataTypes StaticSchema::leafrefBase(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     auto leaf{boost::get<yang::leaf>(children(locationString).at(fullNodeName(location, node)))};
     auto locationOfSource = stripLastNodeFromPath(leaf.m_leafRefSource);
     auto nameOfSource = lastNodeOfSchemaPath(leaf.m_leafRefSource);
@@ -235,13 +243,13 @@
 
 yang::LeafDataTypes StaticSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     return boost::get<yang::leaf>(children(locationString).at(fullNodeName(location, node))).m_type;
 }
 
 const std::set<std::string> StaticSchema::enumValues(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(location);
+    std::string locationString = pathToSchemaString(location, Prefixes::Always);
     assert(isLeaf(location, node));
 
     const auto& child = children(locationString).at(fullNodeName(location, node));
@@ -253,7 +261,7 @@
 // for this class.
 std::set<std::string> StaticSchema::childNodes(const schemaPath_& path, const Recursion) const
 {
-    std::string locationString = pathToAbsoluteSchemaString(path);
+    std::string locationString = pathToSchemaString(path, Prefixes::Always);
     std::set<std::string> res;
 
     auto childrenRef = children(locationString);
diff --git a/src/utils.cpp b/src/utils.cpp
index eb4f432..cd0858f 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -21,10 +21,13 @@
 {
     std::string res = path;
     auto pos = res.find_last_of('/');
-    if (pos == res.npos)
+    if (pos == res.npos) { // path has no backslash - it's either empty, or is a relative path with one fragment
         res.clear();
-    else
+    } else if (pos == 0) { // path has one backslash at the start - it's either "/" or "/one-path-fragment"
+        return "/";
+    } else {
         res.erase(pos);
+    }
     return res;
 }
 
diff --git a/src/yang_schema.cpp b/src/yang_schema.cpp
index 5de3b9e..06259b9 100644
--- a/src/yang_schema.cpp
+++ b/src/yang_schema.cpp
@@ -220,8 +220,7 @@
 
 libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& location, const ModuleNodePair& node) const
 {
-    std::string absPath = location.m_nodes.empty() ? "" : "/";
-    absPath += pathToAbsoluteSchemaString(location) + "/" + fullNodeName(location, node);
+    std::string absPath = joinPaths(pathToSchemaString(location, Prefixes::Always), fullNodeName(location, node));
 
     return impl_getSchemaNode(absPath);
 }
@@ -321,8 +320,8 @@
     if (path.m_nodes.empty()) {
         nodes = m_context->data_instantiables(0);
     } else {
-        const auto absolutePath = "/" + pathToAbsoluteSchemaString(path);
-        const auto node = getSchemaNode(absolutePath);
+        const auto pathString = pathToSchemaString(path, Prefixes::Always);
+        const auto node = getSchemaNode(pathString);
         nodes = node->child_instantiables(0);
     }
 
diff --git a/tests/cd.cpp b/tests/cd.cpp
index 45e7bec..1d03e78 100644
--- a/tests/cd.cpp
+++ b/tests/cd.cpp
@@ -16,16 +16,16 @@
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("example");
     schema->addModule("second");
-    schema->addContainer("", "example:a");
-    schema->addContainer("", "second:a");
-    schema->addContainer("", "example:b");
-    schema->addContainer("example:a", "example:a2");
-    schema->addContainer("example:b", "example:b2");
-    schema->addContainer("example:a/example:a2", "example:a3");
-    schema->addContainer("example:b/example:b2", "example:b3");
-    schema->addList("", "example:list", {"number"});
-    schema->addContainer("example:list", "example:contInList");
-    schema->addList("", "example:twoKeyList", {"number", "name"});
+    schema->addContainer("/", "example:a");
+    schema->addContainer("/", "second:a");
+    schema->addContainer("/", "example:b");
+    schema->addContainer("/example:a", "example:a2");
+    schema->addContainer("/example:b", "example:b2");
+    schema->addContainer("/example:a/example:a2", "example:a3");
+    schema->addContainer("/example:b/example:b2", "example:b3");
+    schema->addList("/", "example:list", {"number"});
+    schema->addContainer("/example:list", "example:contInList");
+    schema->addList("/", "example:twoKeyList", {"number", "name"});
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/enum_completion.cpp b/tests/enum_completion.cpp
index f3cb2e9..a8ec4d2 100644
--- a/tests/enum_completion.cpp
+++ b/tests/enum_completion.cpp
@@ -15,11 +15,11 @@
 {
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("mod");
-    schema->addContainer("", "mod:contA");
-    schema->addLeafEnum("", "mod:leafEnum", {"lala", "lol", "data", "coze"});
-    schema->addLeafEnum("mod:contA", "mod:leafInCont", {"abc", "def"});
-    schema->addList("", "mod:list", {"number"});
-    schema->addLeafEnum("mod:list", "mod:leafInList", {"ano", "anoda", "ne", "katoda"});
+    schema->addContainer("/", "mod:contA");
+    schema->addLeafEnum("/", "mod:leafEnum", {"lala", "lol", "data", "coze"});
+    schema->addLeafEnum("/mod:contA", "mod:leafInCont", {"abc", "def"});
+    schema->addList("/", "mod:list", {"number"});
+    schema->addLeafEnum("/mod:list", "mod:leafInList", {"ano", "anoda", "ne", "katoda"});
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/leaf_editing.cpp b/tests/leaf_editing.cpp
index ca9a5da..edf89b4 100644
--- a/tests/leaf_editing.cpp
+++ b/tests/leaf_editing.cpp
@@ -15,7 +15,7 @@
 
 std::ostream& operator<<(std::ostream& s, const set_ cmd)
 {
-    return s << "Command SET {path: " << pathToAbsoluteSchemaString(cmd.m_path) << ", type " << boost::core::demangle(cmd.m_data.type().name()) << ", data: " << leafDataToString(cmd.m_data) << "}";
+    return s << "Command SET {path: " << pathToSchemaString(cmd.m_path, Prefixes::Always) << ", type " << boost::core::demangle(cmd.m_data.type().name()) << ", data: " << leafDataToString(cmd.m_data) << "}";
 }
 
 TEST_CASE("leaf editing")
@@ -23,33 +23,33 @@
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("mod");
     schema->addModule("pizza-module");
-    schema->addContainer("", "mod:contA");
-    schema->addLeaf("", "mod:leafString", yang::LeafDataTypes::String);
-    schema->addLeaf("", "mod:leafDecimal", yang::LeafDataTypes::Decimal);
-    schema->addLeaf("", "mod:leafBool", yang::LeafDataTypes::Bool);
-    schema->addLeaf("", "mod:leafInt8", yang::LeafDataTypes::Int8);
-    schema->addLeaf("", "mod:leafInt16", yang::LeafDataTypes::Int16);
-    schema->addLeaf("", "mod:leafInt32", yang::LeafDataTypes::Int32);
-    schema->addLeaf("", "mod:leafInt64", yang::LeafDataTypes::Int64);
-    schema->addLeaf("", "mod:leafUint8", yang::LeafDataTypes::Uint8);
-    schema->addLeaf("", "mod:leafUint16", yang::LeafDataTypes::Uint16);
-    schema->addLeaf("", "mod:leafUint32", yang::LeafDataTypes::Uint32);
-    schema->addLeaf("", "mod:leafUint64", yang::LeafDataTypes::Uint64);
-    schema->addLeaf("", "mod:leafBinary", yang::LeafDataTypes::Binary);
+    schema->addContainer("/", "mod:contA");
+    schema->addLeaf("/", "mod:leafString", yang::LeafDataTypes::String);
+    schema->addLeaf("/", "mod:leafDecimal", yang::LeafDataTypes::Decimal);
+    schema->addLeaf("/", "mod:leafBool", yang::LeafDataTypes::Bool);
+    schema->addLeaf("/", "mod:leafInt8", yang::LeafDataTypes::Int8);
+    schema->addLeaf("/", "mod:leafInt16", yang::LeafDataTypes::Int16);
+    schema->addLeaf("/", "mod:leafInt32", yang::LeafDataTypes::Int32);
+    schema->addLeaf("/", "mod:leafInt64", yang::LeafDataTypes::Int64);
+    schema->addLeaf("/", "mod:leafUint8", yang::LeafDataTypes::Uint8);
+    schema->addLeaf("/", "mod:leafUint16", yang::LeafDataTypes::Uint16);
+    schema->addLeaf("/", "mod:leafUint32", yang::LeafDataTypes::Uint32);
+    schema->addLeaf("/", "mod:leafUint64", yang::LeafDataTypes::Uint64);
+    schema->addLeaf("/", "mod:leafBinary", yang::LeafDataTypes::Binary);
     schema->addIdentity(std::nullopt, ModuleValuePair{"mod", "food"});
     schema->addIdentity(std::nullopt, ModuleValuePair{"mod", "vehicle"});
     schema->addIdentity(ModuleValuePair{"mod", "food"}, ModuleValuePair{"mod", "pizza"});
     schema->addIdentity(ModuleValuePair{"mod", "food"}, ModuleValuePair{"mod", "spaghetti"});
     schema->addIdentity(ModuleValuePair{"mod", "pizza"}, ModuleValuePair{"pizza-module", "hawaii"});
-    schema->addLeafIdentityRef("", "mod:foodIdentRef", ModuleValuePair{"mod", "food"});
-    schema->addLeafIdentityRef("", "mod:pizzaIdentRef", ModuleValuePair{"mod", "pizza"});
-    schema->addLeafIdentityRef("mod:contA", "mod:identInCont", ModuleValuePair{"mod", "pizza"});
-    schema->addLeafEnum("", "mod:leafEnum", {"lol", "data", "coze"});
-    schema->addLeaf("mod:contA", "mod:leafInCont", yang::LeafDataTypes::String);
-    schema->addList("", "mod:list", {"number"});
-    schema->addLeaf("mod:list", "mod:leafInList", yang::LeafDataTypes::String);
-    schema->addLeafRef("", "mod:refToString", "mod:leafString");
-    schema->addLeafRef("", "mod:refToInt8", "mod:leafInt8");
+    schema->addLeafIdentityRef("/", "mod:foodIdentRef", ModuleValuePair{"mod", "food"});
+    schema->addLeafIdentityRef("/", "mod:pizzaIdentRef", ModuleValuePair{"mod", "pizza"});
+    schema->addLeafIdentityRef("/mod:contA", "mod:identInCont", ModuleValuePair{"mod", "pizza"});
+    schema->addLeafEnum("/", "mod:leafEnum", {"lol", "data", "coze"});
+    schema->addLeaf("/mod:contA", "mod:leafInCont", yang::LeafDataTypes::String);
+    schema->addList("/", "mod:list", {"number"});
+    schema->addLeaf("/mod:list", "mod:leafInList", yang::LeafDataTypes::String);
+    schema->addLeafRef("/", "mod:refToString", "/mod:leafString");
+    schema->addLeafRef("/", "mod:refToInt8", "/mod:leafInt8");
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/list_manipulation.cpp b/tests/list_manipulation.cpp
index 717ce3a..3fa7a8b 100644
--- a/tests/list_manipulation.cpp
+++ b/tests/list_manipulation.cpp
@@ -13,8 +13,8 @@
 {
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("mod");
-    schema->addList("", "mod:list", {"number"});
-    schema->addLeaf("mod:list", "mod:leafInList", yang::LeafDataTypes::String);
+    schema->addList("/", "mod:list", {"number"});
+    schema->addLeaf("/mod:list", "mod:leafInList", yang::LeafDataTypes::String);
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/ls.cpp b/tests/ls.cpp
index fffac28..0df428b 100644
--- a/tests/ls.cpp
+++ b/tests/ls.cpp
@@ -16,17 +16,17 @@
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("example");
     schema->addModule("second");
-    schema->addContainer("", "example:a");
-    schema->addList("example:a", "example:listInCont", {"number"});
-    schema->addContainer("", "second:a");
-    schema->addContainer("", "example:b");
-    schema->addContainer("example:a", "example:a2");
-    schema->addContainer("example:b", "example:b2");
-    schema->addContainer("example:a/example:a2", "example:a3");
-    schema->addContainer("example:b/example:b2", "example:b3");
-    schema->addList("", "example:list", {"number"});
-    schema->addContainer("example:list", "example:contInList");
-    schema->addList("", "example:twoKeyList", {"number", "name"});
+    schema->addContainer("/", "example:a");
+    schema->addList("/example:a", "example:listInCont", {"number"});
+    schema->addContainer("/", "second:a");
+    schema->addContainer("/", "example:b");
+    schema->addContainer("/example:a", "example:a2");
+    schema->addContainer("/example:b", "example:b2");
+    schema->addContainer("/example:a/example:a2", "example:a3");
+    schema->addContainer("/example:b/example:b2", "example:b3");
+    schema->addList("/", "example:list", {"number"});
+    schema->addContainer("/example:list", "example:contInList");
+    schema->addList("/", "example:twoKeyList", {"number", "name"});
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/parser_methods.cpp b/tests/parser_methods.cpp
index 57e6e56..2a84428 100644
--- a/tests/parser_methods.cpp
+++ b/tests/parser_methods.cpp
@@ -28,17 +28,17 @@
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("example");
     schema->addModule("second");
-    schema->addContainer("", "example:a");
-    schema->addList("example:a", "example:listInCont", {"number"});
-    schema->addContainer("", "second:a");
-    schema->addContainer("", "example:b");
-    schema->addContainer("example:a", "example:a2");
-    schema->addContainer("example:b", "example:b2");
-    schema->addContainer("example:a/example:a2", "example:a3");
-    schema->addContainer("example:b/example:b2", "example:b3");
-    schema->addList("", "example:list", {"number"});
-    schema->addContainer("example:list", "example:contInList");
-    schema->addList("", "example:twoKeyList", {"number", "name"});
+    schema->addContainer("/", "example:a");
+    schema->addList("/example:a", "example:listInCont", {"number"});
+    schema->addContainer("/", "second:a");
+    schema->addContainer("/", "example:b");
+    schema->addContainer("/example:a", "example:a2");
+    schema->addContainer("/example:b", "example:b2");
+    schema->addContainer("/example:a/example:a2", "example:a3");
+    schema->addContainer("/example:b/example:b2", "example:b3");
+    schema->addList("/", "example:list", {"number"});
+    schema->addContainer("/example:list", "example:contInList");
+    schema->addList("/", "example:twoKeyList", {"number", "name"});
     Parser parser(schema);
 
     SECTION("availableNodes")
diff --git a/tests/path_completion.cpp b/tests/path_completion.cpp
index cff254f..115cfdd 100644
--- a/tests/path_completion.cpp
+++ b/tests/path_completion.cpp
@@ -26,21 +26,21 @@
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("example");
     schema->addModule("second");
-    schema->addContainer("", "example:ano");
-    schema->addContainer("", "example:anoda");
-    schema->addList("example:ano", "example:listInCont", {"number"});
-    schema->addContainer("", "second:amelie");
-    schema->addContainer("", "example:bota");
-    schema->addContainer("example:ano", "example:a2");
-    schema->addContainer("example:bota", "example:b2");
-    schema->addContainer("example:ano/example:a2", "example:a3");
-    schema->addContainer("example:bota/example:b2", "example:b3");
-    schema->addList("", "example:list", {"number"});
-    schema->addList("", "example:ovoce", {"name"});
-    schema->addList("", "example:ovocezelenina", {"name"});
-    schema->addContainer("example:list", "example:contInList");
-    schema->addList("", "example:twoKeyList", {"number", "name"});
-    schema->addLeaf("", "example:leafInt", yang::LeafDataTypes::Int32);
+    schema->addContainer("/", "example:ano");
+    schema->addContainer("/", "example:anoda");
+    schema->addList("/example:ano", "example:listInCont", {"number"});
+    schema->addContainer("/", "second:amelie");
+    schema->addContainer("/", "example:bota");
+    schema->addContainer("/example:ano", "example:a2");
+    schema->addContainer("/example:bota", "example:b2");
+    schema->addContainer("/example:ano/example:a2", "example:a3");
+    schema->addContainer("/example:bota/example:b2", "example:b3");
+    schema->addList("/", "example:list", {"number"});
+    schema->addList("/", "example:ovoce", {"name"});
+    schema->addList("/", "example:ovocezelenina", {"name"});
+    schema->addContainer("/example:list", "example:contInList");
+    schema->addList("/", "example:twoKeyList", {"number", "name"});
+    schema->addLeaf("/", "example:leafInt", yang::LeafDataTypes::Int32);
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
diff --git a/tests/path_utils.cpp b/tests/path_utils.cpp
index eba2b34..f8dc250 100644
--- a/tests/path_utils.cpp
+++ b/tests/path_utils.cpp
@@ -28,6 +28,6 @@
             path.m_nodes.push_back(dataNode_{module_{"example-schema"}, listElement_{"twoKeyList", {{"first", "a"}, {"second", "b"}}}});
             expected += "example-schema:twoKeyList[first='a'][second='b']";
         }
-        REQUIRE(pathToDataString(path) == expected);
+        REQUIRE(pathToDataString(path, Prefixes::WhenNeeded) == expected);
     }
 }
diff --git a/tests/presence_containers.cpp b/tests/presence_containers.cpp
index e027fb9..ba8938e 100644
--- a/tests/presence_containers.cpp
+++ b/tests/presence_containers.cpp
@@ -16,13 +16,13 @@
 {
     auto schema = std::make_shared<StaticSchema>();
     schema->addModule("mod");
-    schema->addContainer("", "mod:a", yang::ContainerTraits::Presence);
-    schema->addContainer("", "mod:b");
-    schema->addContainer("mod:a", "mod:a2");
-    schema->addContainer("mod:a/mod:a2", "mod:a3", yang::ContainerTraits::Presence);
-    schema->addContainer("mod:b", "mod:b2", yang::ContainerTraits::Presence);
-    schema->addList("", "mod:list", {"quote"});
-    schema->addContainer("mod:list", "mod:contInList", yang::ContainerTraits::Presence);
+    schema->addContainer("/", "mod:a", yang::ContainerTraits::Presence);
+    schema->addContainer("/", "mod:b");
+    schema->addContainer("/mod:a", "mod:a2");
+    schema->addContainer("/mod:a/mod:a2", "mod:a3", yang::ContainerTraits::Presence);
+    schema->addContainer("/mod:b", "mod:b2", yang::ContainerTraits::Presence);
+    schema->addList("/", "mod:list", {"quote"});
+    schema->addContainer("/mod:list", "mod:contInList", yang::ContainerTraits::Presence);
     Parser parser(schema);
     std::string input;
     std::ostringstream errorStream;
@@ -80,7 +80,7 @@
         create_ create = boost::get<create_>(commandCreate);
         REQUIRE(create == expectedCreate);
 
-        REQUIRE(pathToDataString(create.m_path) == input);
+        REQUIRE(pathToDataString(create.m_path, Prefixes::WhenNeeded) == input);
 
         delete_ expectedDelete;
         expectedDelete.m_path = expectedPath;
diff --git a/tests/yang.cpp b/tests/yang.cpp
index d519825..fa394b5 100644
--- a/tests/yang.cpp
+++ b/tests/yang.cpp
@@ -284,7 +284,7 @@
     });
     ys.addSchemaString(second_schema);
 
-    schemaPath_ path;
+    schemaPath_ path{Scope::Absolute, {}};
     ModuleNodePair node;
 
     SECTION("positive")