def hbds_release_branch(self) -> str:
        """Translate the release into a HardenedBSD release git branch name."""
        if self._hbsd_release_branch is not None:
            return self._hbsd_release_branch

        if self.fetched is False:
            raise libioc.errors.ReleaseNotFetched(
                name=self.name,
                logger=self.logger
            )

        root_dataset_mountpoint = self.root_dataset.mountpoint
        source_file = f"{root_dataset_mountpoint}/etc/hbsd-update.conf"

        if not os.path.isfile(source_file):
            raise libioc.errors.ReleaseUpdateBranchLookup(
                release_name=self.name,
                reason=f"{source_file} not found",
                logger=self.logger
            )

        libioc.helpers.require_no_symlink(source_file, logger=self.logger)

        with open(source_file, "r", encoding="utf-8") as f:
            import ucl
            hbsd_update_conf = ucl.load(f.read())
            self._hbsd_release_branch = hbsd_update_conf["branch"]
            return str(self._hbsd_release_branch)

 def test_boolean(self):
     totest = (
         "a : True;" \
         "b : False"
     )
     correct = {"a" : True, "b" : False}
     self.assertEqual(ucl.load(totest), correct)

 def test_every_type(self):
     data = ("""{
         "key1": value;
         "key2": value2;
         "key3": "value;"
         "key4": 1.0,
         "key5": -0xdeadbeef
         "key6": 0xdeadbeef.1
         "key7": 0xreadbeef
         "key8": -1e-10,
         "key9": 1
         "key10": true
         "key11": no
         "key12": yes
     }""")
     valid = {
         'key1': 'value',
         'key2': 'value2',
         'key3': 'value;',
         'key4': 1.0,
         'key5': -3735928559,
         'key6': '0xdeadbeef.1',
         'key7': '0xreadbeef',
         'key8': -1e-10,
         'key9': 1,
         'key10': True,
         'key11': False,
         'key12': True,
         }
     self.assertEqual(ucl.load(data), valid)

 def test_every_type(self):
     totest="""{
         "key1": value;
         "key2": value2;
         "key3": "value;"
         "key4": 1.0,
         "key5": -0xdeadbeef
         "key6": 0xdeadbeef.1
         "key7": 0xreadbeef
         "key8": -1e-10,
         "key9": 1
         "key10": true
         "key11": no
         "key12": yes
     }"""
     correct = {
             'key1': 'value',
             'key2': 'value2',
             'key3': 'value;',
             'key4': 1.0,
             'key5': -3735928559,
             'key6': '0xdeadbeef.1',
             'key7': '0xreadbeef',
             'key8': -1e-10,
             'key9': 1,
             'key10': 'true',
             'key11': 'false',
             'key12': 'true',
             }
     self.assertEqual(ucl.load(totest), correct)

 def test_boolean(self):
     data = (
         "a : True;" \
         "b : False"
     )
     valid = { "a" : True, "b" : False }
     self.assertEqual(ucl.load(data), valid)

 def test_braced_int(self):
     self.assertEqual(ucl.load("{a : 1}"), { "a" : 1 } )

 def test_int(self):
     r = ucl.load("a : 1")
     self.assertEqual(ucl.load("a : 1"), { "a" : 1 } )

 def test_none(self):
     self.assertEqual(ucl.load(None), None)

 def test_braced_int(self):
     data  = "{a : 1}"
     valid = { "a" : 1 }
     self.assertEqual(ucl.load(data), valid)

 def test_single_brace(self):
     self.assertEqual(ucl.load("{"), {})

 def test_float(self):
     self.assertEqual(ucl.load("a : 1.1"), {"a" : 1.1})

 def test_no_args(self):
     self.assertRaises(TypeError, lambda: ucl.load())

 def test_empty_ucl(self):
     self.assertEqual(ucl.load("{}"), {})

 def test_float(self):
     data  = "a : 1.1"
     valid = {"a" : 1.1}
     self.assertEqual(ucl.load(data), valid)

 def test_str(self):
     data  = "a : b"
     valid = { "a" : "b" }
     self.assertEqual(ucl.load(data), valid)

 def test_nested_int(self):
     data  = "a : { b : 1 }"
     valid = { "a" : { "b" : 1 } }
     self.assertEqual(ucl.load(data), valid)

 def test_nested_int(self):
     self.assertEqual(ucl.load("a : { b : 1 }"), { "a" : { "b" : 1 } })

 def test_multi_args(self):
     self.assertRaises(TypeError, lambda: ucl.load(0,0))

 def test_str(self):
     self.assertEqual(ucl.load("a : b"), {"a" : "b"})

 def test_single_square_forward(self):
     self.assertEqual(ucl.load("["), [])