diff --git a/tests/datastore_access.cpp b/tests/datastore_access.cpp
index e32076c..b7c4944 100644
--- a/tests/datastore_access.cpp
+++ b/tests/datastore_access.cpp
@@ -22,6 +22,7 @@
 using OnInvalidRpcInput = sysrepo::ErrorWithCode;
 using OnKeyNotFound = void;
 using OnExec = void;
+using OnInvalidRequireInstance = DatastoreException;
 #elif defined(netconf_BACKEND)
 using OnInvalidSchemaPathCreate = std::runtime_error;
 using OnInvalidSchemaPathDelete = std::runtime_error;
@@ -30,6 +31,7 @@
 using OnInvalidRpcInput = std::runtime_error;
 using OnKeyNotFound = std::runtime_error;
 using OnExec = void;
+using OnInvalidRequireInstance = std::runtime_error;
 #include "netconf_access.hpp"
 #elif defined(yang_BACKEND)
 #include <fstream>
@@ -42,6 +44,7 @@
 using OnInvalidRpcInput = std::logic_error;
 using OnKeyNotFound = DatastoreException;
 using OnExec = std::logic_error;
+using OnInvalidRequireInstance = std::runtime_error;
 #else
 #error "Unknown backend"
 #endif
@@ -532,6 +535,43 @@
         REQUIRE(datastore.getItems("/example-schema:flags") == expected);
     }
 
+    SECTION("instance-identifier")
+    {
+        SECTION("simple")
+        {
+            datastore.setLeaf("/example-schema:lol/up", true);
+            datastore.setLeaf("/example-schema:iid-valid", instanceIdentifier_{"/example-schema:lol/up"});
+            REQUIRE_CALL(mockRunning, write(sysrepo::ChangeOperation::Created, "/example-schema:lol/up", std::nullopt, "true"s, std::nullopt));
+            REQUIRE_CALL(mockRunning, write(sysrepo::ChangeOperation::Created, "/example-schema:iid-valid", std::nullopt, "/example-schema:lol/up"s, std::nullopt));
+            datastore.commitChanges();
+            DatastoreAccess::Tree expected{
+                {"/example-schema:iid-valid", instanceIdentifier_{"/example-schema:lol/up"}},
+            };
+            REQUIRE(datastore.getItems("/example-schema:iid-valid") == expected);
+        }
+
+        SECTION("to a non-existing list without require-instance")
+        {
+            datastore.setLeaf("/example-schema:iid-relaxed", instanceIdentifier_{"/example-schema:ports[name='A']/shutdown"});
+            REQUIRE_CALL(mockRunning, write(sysrepo::ChangeOperation::Created, "/example-schema:iid-relaxed", std::nullopt, "/example-schema:ports[name='A']/shutdown"s, std::nullopt));
+            datastore.commitChanges();
+            DatastoreAccess::Tree expected{
+                {"/example-schema:iid-relaxed", instanceIdentifier_{"/example-schema:ports[name='A']/shutdown"}},
+            };
+            REQUIRE(datastore.getItems("/example-schema:iid-relaxed") == expected);
+        }
+
+        SECTION("to a non-existing list with require-instance")
+        {
+            catching<OnInvalidRequireInstance>([&] {
+                datastore.setLeaf("/example-schema:iid-valid", instanceIdentifier_{"/example-schema:ports[name='A']/shutdown"});
+                datastore.commitChanges();
+            });
+            datastore.discardChanges();
+        }
+    }
+
+
 #if not defined(yang_BACKEND)
     SECTION("operational data")
     {
diff --git a/tests/example-schema.yang b/tests/example-schema.yang
index 6e040ae..db27d57 100644
--- a/tests/example-schema.yang
+++ b/tests/example-schema.yang
@@ -341,4 +341,13 @@
         }
     }
 
+    leaf iid-valid {
+        type instance-identifier;
+    }
+
+    leaf iid-relaxed {
+        type instance-identifier {
+            require-instance false;
+        }
+    }
 }
diff --git a/tests/leaf_editing.cpp b/tests/leaf_editing.cpp
index 5965110..302c8e4 100644
--- a/tests/leaf_editing.cpp
+++ b/tests/leaf_editing.cpp
@@ -72,6 +72,9 @@
     schema->addLeaf("/", "mod:readonly", yang::Int32{}, yang::AccessType::ReadOnly);
 
     schema->addLeaf("/", "mod:flags", yang::Bits{{"carry", "sign"}});
+    schema->addLeaf("/", "mod:iid", yang::InstanceIdentifier{});
+    schema->addLeaf("/mod:contA", "mod:x", yang::String{});
+    schema->addLeaf("/mod:contA", "mod:iid", yang::InstanceIdentifier{});
 
     Parser parser(schema);
     std::string input;
@@ -509,6 +512,47 @@
             }
         }
 
+        SECTION("instance-identifier") {
+            SECTION("toplevel")
+            {
+                input = "set mod:iid /mod:leafUint32";
+                expected.m_path.m_nodes.emplace_back(module_{"mod"}, leaf_{"iid"});
+                expected.m_data = instanceIdentifier_{"/mod:leafUint32"};
+            }
+
+            SECTION("deep to toplevel")
+            {
+                input = "set mod:contA/iid /mod:leafUint32";
+                expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+                expected.m_path.m_nodes.emplace_back(leaf_{"iid"});
+                expected.m_data = instanceIdentifier_{"/mod:leafUint32"};
+            }
+
+            SECTION("deep to deep unprefixed")
+            {
+                input = "set mod:contA/iid /mod:contA/x";
+                expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+                expected.m_path.m_nodes.emplace_back(leaf_{"iid"});
+                expected.m_data = instanceIdentifier_{"/mod:contA/x"};
+            }
+
+            SECTION("deep to deep mod-prefixed")
+            {
+                input = "set mod:contA/iid /mod:contA/mod:x";
+                expected.m_path.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+                expected.m_path.m_nodes.emplace_back(leaf_{"iid"});
+                expected.m_data = instanceIdentifier_{"/mod:contA/mod:x"};
+            }
+
+            SECTION("absolute when nested")
+            {
+                cwd.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+                input = "set iid /mod:contA/x";
+                expected.m_path.m_nodes.emplace_back(leaf_{"iid"});
+                expected.m_data = instanceIdentifier_{"/mod:contA/x"};
+            }
+        }
+
         parser.changeNode(cwd);
         command_ command = parser.parseCommand(input, errorStream);
         REQUIRE(command.type() == typeid(set_));
@@ -683,6 +727,39 @@
             input = "set mod:flags carry carry";
         }
 
+        SECTION("instance-identifier non-existing node")
+        {
+            input = "set mod:iid /mod:404";
+        }
+
+        SECTION("instance-identifier non-existing node without leading slash")
+        {
+            input = "set mod:iid mod:404";
+        }
+
+        SECTION("instance-identifier node without leading slash")
+        {
+            input = "set mod:iid mod:leafUint32";
+        }
+
+        SECTION("instance-identifier to pseudo-relative unprefixed")
+        {
+            cwd.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+            input = "set iid x";
+        }
+
+        SECTION("instance-identifier to pseudo-relative prefixed")
+        {
+            cwd.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+            input = "set iid mod:x";
+        }
+
+        SECTION("instance-identifier without leading slash when nested")
+        {
+            cwd.m_nodes.emplace_back(module_{"mod"}, container_{"contA"});
+            input = "set iid mod:contA/x";
+        }
+
         parser.changeNode(cwd);
         REQUIRE_THROWS_AS(parser.parseCommand(input, errorStream), InvalidCommandException);
         REQUIRE(errorStream.str().find(expectedError) != std::string::npos);
diff --git a/tests/path_completion.cpp b/tests/path_completion.cpp
index be676c9..8ad4b35 100644
--- a/tests/path_completion.cpp
+++ b/tests/path_completion.cpp
@@ -44,6 +44,7 @@
     schema->addContainer("/", "example:system");
     schema->addContainer("/example:system", "example:thing");
     schema->addContainer("/", "example:system-state");
+    schema->addLeaf("/example:anoda", "example:iid", yang::InstanceIdentifier{});
     auto mockDatastore = std::make_shared<MockDatastoreAccess>();
 
     // The parser will use DataQuery for key value completion, but I'm not testing that here, so I don't return anything.
@@ -195,6 +196,42 @@
             expectedCompletions = {"example:system-state/"};
             expectedContextLength = 15;
         }
+
+        SECTION("set example:anoda/iid ")
+        {
+            input = "set example:anoda/iid ";
+            expectedCompletions = {"/"};
+            expectedContextLength = 0;
+        }
+
+        SECTION("set example:anoda/iid /")
+        {
+            input = "set example:anoda/iid /";
+            expectedCompletions = {
+                "example:addresses",
+                "example:ano/",
+                "example:anoda/",
+                "example:bota/",
+                "example:leafInt ",
+                "example:list",
+                "example:ovoce",
+                "example:ovocezelenina",
+                "example:readonly ",
+                "example:system-state/",
+                "example:system/",
+                "example:twoKeyList",
+                "second:amelie/",
+                "second:fire/",
+            };
+            expectedContextLength = 0;
+        }
+
+        SECTION("set example:anoda/iid /example:read")
+        {
+            input = "set example:anoda/iid /example:read";
+            expectedCompletions = {"example:readonly "};
+            expectedContextLength = 12;
+        }
     }
 
     SECTION("get completion")
diff --git a/tests/utils.cpp b/tests/utils.cpp
index fa4ebed..05dfeb2 100644
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -217,6 +217,16 @@
             }
         }
     }
+
+    leaf iid-valid {
+        type instance-identifier;
+    }
+
+    leaf iid-relaxed {
+        type instance-identifier {
+            require-instance false;
+        }
+    }
 }
 )"s;
 
@@ -257,7 +267,9 @@
                 "name": "Aneta"
             }
         ]
-    }
+    },
+    "test-schema:iid-valid": "/test-schema:stuff[name='Xaver']/name",
+    "test-schema:iid-relaxed": "/test-schema:stuff[name='XXX']/name"
 }
 )"s;
 
@@ -392,6 +404,8 @@
             {"/test-schema:users/userList[2]/name", std::string{"Aneta"}},
             {"/test-schema:users/userList[3]", special_{SpecialValue::List}},
             {"/test-schema:users/userList[3]/name", std::string{"Aneta"}},
+            {"/test-schema:iid-valid", instanceIdentifier_{"/test-schema:stuff[name='Xaver']/name"}},
+            {"/test-schema:iid-relaxed", instanceIdentifier_{"/test-schema:stuff[name='XXX']/name"}},
         };
 
         DatastoreAccess::Tree tree;
diff --git a/tests/yang.cpp b/tests/yang.cpp
index 0ba0af8..f56a27b 100644
--- a/tests/yang.cpp
+++ b/tests/yang.cpp
@@ -473,6 +473,16 @@
             bit overflow;
         }
     }
+
+    leaf iid-valid {
+        type instance-identifier;
+    }
+
+    leaf iid-relaxed {
+        type instance-identifier {
+            require-instance false;
+        }
+    }
 })";
 
 TEST_CASE("yangschema")
@@ -793,6 +803,20 @@
                 type = yang::IdentityRef{{}};
             }
 
+            SECTION("instance-identifier required")
+            {
+                node.first = "example-schema";
+                node.second = "iid-valid";
+                type = yang::InstanceIdentifier{};
+            }
+
+            SECTION("instance-identifier relaxed")
+            {
+                node.first = "example-schema";
+                node.second = "iid-relaxed";
+                type = yang::InstanceIdentifier{};
+            }
+
             REQUIRE(ys.leafType(path, node) == yang::TypeInfo(type, std::nullopt, expectedDescription));
         }
         SECTION("availableNodes")
@@ -841,7 +865,10 @@
                         {"example-schema"s, "subLeaf"},
                         {"example-schema"s, "flagBits"},
                         {"example-schema"s, "leafFoodTypedef"},
-                        {"example-schema"s, "leafNoValidIdent"}};
+                        {"example-schema"s, "leafNoValidIdent"},
+                        {"example-schema"s, "iid-valid"},
+                        {"example-schema"s, "iid-relaxed"},
+                    };
                 }
 
                 SECTION("example-schema:a")
@@ -898,6 +925,8 @@
                         {"example-schema"s, "foodIdentLeaf"},
                         {"example-schema"s, "flagBits"},
                         {"example-schema"s, "interrupt"},
+                        {"example-schema"s, "iid-relaxed"},
+                        {"example-schema"s, "iid-valid"},
                         {"example-schema"s, "leafBool"},
                         {"example-schema"s, "leafDecimal"},
                         {"example-schema"s, "leafEnum"},
@@ -966,6 +995,8 @@
                         {boost::none, "/example-schema:ethernet/ip"},
                         {boost::none, "/example-schema:loopback"},
                         {boost::none, "/example-schema:loopback/ip"},
+                        {boost::none, "/example-schema:iid-relaxed"},
+                        {boost::none, "/example-schema:iid-valid"},
                         {boost::none, "/example-schema:interrupt"},
                         {boost::none, "/example-schema:leafBool"},
                         {boost::none, "/example-schema:leafDecimal"},