def setUpClass(cls): cls.mpath = utils.decode(G_mapset_path()) cls.mapset_name = Mapset().name cls.sigdirs = [] # As signatures are created directly not via signature creation # tools, we must ensure signature directories exist os.makedirs(f"{cls.mpath}/signatures/sig/", exist_ok=True) os.makedirs(f"{cls.mpath}/signatures/sigset/", exist_ok=True) # A mapset with a random name cls.src_mapset_name = tempname(10) G_make_mapset(None, None, cls.src_mapset_name) cls.src_mapset_path = (cls.mpath.rsplit("/", maxsplit=1)[0] + "/" + cls.src_mapset_name) # Create fake signature files os.makedirs(f"{cls.src_mapset_path}/signatures/sig/") cls.src_sig = tempname(10) cls.src_sig_dir = f"{cls.src_mapset_path}/signatures/sig/{cls.src_sig}" os.makedirs(cls.src_sig_dir) cls.sigdirs.append(cls.src_sig_dir) f = open(f"{cls.src_sig_dir}/sig", "w") f.write("A sig file") f.close() os.makedirs(f"{cls.src_mapset_path}/signatures/sigset/") cls.src_sigset = tempname(10) cls.src_sigset_dir = f"{cls.src_mapset_path}/signatures/sigset/{cls.src_sigset}" os.makedirs(cls.src_sigset_dir) cls.sigdirs.append(cls.src_sigset_dir) f = open(f"{cls.src_sigset_dir}/sig", "w") f.write("A sigset file") f.close()
def test_sig_in_different_mapset(self): # Should return 0 signatures from a different mapset # Sig type local_sig = tempname(10) sig_dir = f"{self.mpath}/signatures/sig/{local_sig}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sig file") f.close() sig_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIG, self.rnd_mapset_name, ctypes.byref(sig_list)) shutil.rmtree(sig_dir) self.assertEqual(ret, 0) I_free_signatures_list(ret, ctypes.byref(sig_list)) # SigSet type local_sigset = tempname(10) sig_dir = f"{self.mpath}/signatures/sigset/{local_sigset}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sigset file") f.close() sig_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIGSET, self.rnd_mapset_name, ctypes.byref(sig_list)) shutil.rmtree(sig_dir) self.assertEqual(ret, 0) I_free_signatures_list(ret, ctypes.byref(sig_list))
def test_find_sigset(self): # Non existing without a mapset ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, tempname(10), None) self.assertFalse(ret) # Non existing with a mapset ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, tempname(10), self.mapset_name) self.assertFalse(ret) # Sig with sigset type should equal non existing ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, self.sig_name2, self.mapset_name) self.assertFalse(ret) # Existing without a mapset ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, self.sig_name1, None) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) # Existing with a mapset ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, self.sig_name1, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) # Existing in a different mapset should fail ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, self.sig_name1, "PERMANENT") self.assertFalse(ret)
def test_remove_nonexisting_sigset(self): # Set up files and mark for clean-up sig_name1 = tempname(10) sig_dir1 = f"{self.mpath}/signatures/sigset/{sig_name1}" os.makedirs(sig_dir1) self.sigdirs.append(sig_dir1) sigfile_name1 = f"{sig_dir1}/sig" open(sigfile_name1, "a").close() sig_name2 = tempname(10) # Do not create sig_name2 matching file sig_name3 = tempname(10) sig_dir3 = f"{self.mpath}/signatures/sig/{sig_name3}" os.makedirs(sig_dir3) self.sigdirs.append(sig_dir3) sigfile_name3 = f"{sig_dir3}/sig" open(sigfile_name3, "a").close() # Now remove one (should fail as file doesn't exist) ret = I_signatures_remove(I_SIGFILE_TYPE_SIGSET, sig_name2) self.assertEqual(ret, 1) # removed should be still absent ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, sig_name2, self.mapset_name) self.assertFalse(ret) # All others should remain ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, sig_name1, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) ret = I_find_signature(I_SIGFILE_TYPE_SIG, sig_name3, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name)
def test_success_fq_sigset(self): src_sigset = tempname(10) sig_dir = f"{self.mpath}/signatures/sigset/{src_sigset}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sigset file") f.close() dst_name = tempname(10) self.sigdirs.append(f"{self.mpath}/signatures/sigset/{dst_name}") dst = dst_name + "@" + self.mapset_name ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, dst, self.mapset_name) self.assertFalse(ret) ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, src_sigset, self.mapset_name) self.assertTrue(ret) ret = I_signatures_rename( I_SIGFILE_TYPE_SIGSET, src_sigset + "@" + self.mapset_name, dst, ) self.assertEqual(ret, 0) ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, dst, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) self.assertTrue( os.path.isfile(f"{self.mpath}/signatures/sigset/{dst_name}/sig"))
def test_multiple_sigsets_multiple_mapsets(self): # Test searching in multiple mapsets. Identical to SIG case rnd_sig1 = tempname(10) sig_dir1 = f"{self.rnd_mapset_path}/signatures/sigset/{rnd_sig1}" os.makedirs(sig_dir1) self.sigdirs.append(sig_dir1) f = open(f"{sig_dir1}/sig", "w") f.write("A sigset file") f.close() rnd_sig2 = tempname(10) sig_dir2 = f"{self.mpath}/signatures/sigset/{rnd_sig2}" os.makedirs(sig_dir2) self.sigdirs.append(sig_dir2) f = open(f"{sig_dir2}/sig", "w") f.write("A sigset file") f.close() sig_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIGSET, None, ctypes.byref(sig_list)) # As temporary mapset is not in the search path, there must be # at least one sig file present # There could be more sigs if this is not an empty mapset self.assertTrue(ret >= 1) ret_list = list(map(utils.decode, sig_list[:ret])) golden = ( f"{rnd_sig1}@{self.rnd_mapset_name}", f"{rnd_sig2}@{self.mapset_name}", ) self.assertIn(golden[1], ret_list) # Temporary mapset is not in the search path: self.assertNotIn(golden[0], ret_list) I_free_signatures_list(ret, ctypes.byref(sig_list)) # Add temporary mapset to search path and re-run test grass.run_command("g.mapsets", mapset=self.rnd_mapset_name, operation="add") # Search path is cached for this run => reset! G_reset_mapsets() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIGSET, None, ctypes.byref(sig_list)) grass.run_command("g.mapsets", mapset=self.rnd_mapset_name, operation="remove") G_reset_mapsets() shutil.rmtree(sig_dir1) shutil.rmtree(sig_dir2) # There could be more sigs if this is not an empty mapset self.assertTrue(ret >= 2) ret_list = list(map(utils.decode, sig_list[:ret])) self.assertIn(golden[0], ret_list) self.assertIn(golden[1], ret_list) I_free_signatures_list(ret, ctypes.byref(sig_list))
def test_remove_existing_sigset(self): # Set up files and mark for clean-up sig_name1 = tempname(10) sig_dir1 = f"{self.mpath}/signatures/sigset/{sig_name1}" os.makedirs(sig_dir1) self.sigdirs.append(sig_dir1) sigfile_name1 = f"{sig_dir1}/sig" open(sigfile_name1, "a").close() sig_name2 = tempname(10) sig_dir2 = f"{self.mpath}/signatures/sigset/{sig_name2}" os.makedirs(sig_dir2) self.sigdirs.append(sig_dir2) sigfile_name2 = f"{sig_dir2}/sig" open(sigfile_name2, "a").close() sig_name3 = tempname(10) sig_dir3 = f"{self.mpath}/signatures/sig/{sig_name3}" os.makedirs(sig_dir3) self.sigdirs.append(sig_dir3) sigfile_name3 = f"{sig_dir3}/sig" open(sigfile_name3, "a").close() # Try to remove with wrong type ret = I_signatures_remove(I_SIGFILE_TYPE_SIG, sig_name2) self.assertEqual(ret, 1) # Try to remove with wrong mapset ret = I_signatures_remove(I_SIGFILE_TYPE_SIGSET, f"{sig_name2}@PERMANENT") self.assertEqual(ret, 1) # Should be still present ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, sig_name2, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) # Now remove with correct type ret = I_signatures_remove(I_SIGFILE_TYPE_SIGSET, sig_name2) self.assertEqual(ret, 0) # removed should be gone ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, sig_name2, self.mapset_name) self.assertFalse(ret) # Others should remain ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, sig_name1, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) ret = I_find_signature(I_SIGFILE_TYPE_SIG, sig_name3, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name)
def setUpClass(cls): cls.libc = ctypes.cdll.LoadLibrary(ctypes.util.find_library("c")) cls.mapset = Mapset().name cls.map1 = tempname(10) cls.semantic_label1 = "The_Doors" cls.map2 = tempname(10) cls.semantic_label2 = "The_Who" cls.map3 = tempname(10) cls.use_temp_region() cls.runModule("g.region", n=1, s=0, e=1, w=0, res=1) cls.runModule("r.mapcalc", expression=f"{cls.map1} = 1") cls.runModule("r.mapcalc", expression=f"{cls.map2} = 1") cls.runModule("r.mapcalc", expression=f"{cls.map3} = 1") Rast_write_semantic_label(cls.map1, cls.semantic_label1) Rast_write_semantic_label(cls.map2, cls.semantic_label2)
def setUpClass(cls): cls.org_mapset = Mapset() cls.tmp_mapset_name = tempname(10) make_mapset(mapset=cls.tmp_mapset_name) cls.tmp_mapset = Mapset(mapset=cls.tmp_mapset_name) cls.tmp_mapset.current() cls.tmp_mapset_path = cls.tmp_mapset.path()
def setUpClass(cls): cls.map = tempname(10) cls.mapset = Mapset().name cls.bandref = "The_Doors" cls.use_temp_region() cls.runModule("g.region", n=1, s=0, e=1, w=0, res=1) cls.runModule("r.mapcalc", expression="{} = 1".format(cls.map))
def setUpClass(cls): cls.mpath = utils.decode(G_mapset_path()) cls.mapset_name = Mapset().name cls.sigdirs = [] # As signatures are created directly not via signature creation # tools, we must ensure signature directories exist os.makedirs(f"{cls.mpath}/signatures/sig/", exist_ok=True) os.makedirs(f"{cls.mpath}/signatures/sigset/", exist_ok=True) cls.sig_name1 = tempname(10) cls.sig_dir1 = f"{cls.mpath}/signatures/sigset/{cls.sig_name1}" os.makedirs(cls.sig_dir1) cls.sigdirs.append(cls.sig_dir1) open(f"{cls.sig_dir1}/sig", "a").close() cls.sig_name2 = tempname(10) cls.sig_dir2 = f"{cls.mpath}/signatures/sig/{cls.sig_name2}" os.makedirs(cls.sig_dir2) cls.sigdirs.append(cls.sig_dir2) open(f"{cls.sig_dir2}/sig", "a").close()
def test_success_unqualified_sig(self): src_sig = tempname(10) sig_dir = f"{self.mpath}/signatures/sig/{src_sig}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sig file") f.close() dst = tempname(10) self.sigdirs.append(f"{self.mpath}/signatures/sig/{dst}") ret = I_find_signature(I_SIGFILE_TYPE_SIG, dst, self.mapset_name) self.assertFalse(ret) ret = I_find_signature(I_SIGFILE_TYPE_SIG, src_sig, self.mapset_name) self.assertTrue(ret) ret = I_signatures_rename(I_SIGFILE_TYPE_SIG, src_sig, dst) self.assertEqual(ret, 0) ret = I_find_signature(I_SIGFILE_TYPE_SIG, dst, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) self.assertTrue( os.path.isfile(f"{self.mpath}/signatures/sig/{dst}/sig"))
def test_single_sig(self): # Case when only a single signature file is present # Sig type rnd_sig = tempname(10) sig_dir = f"{self.rnd_mapset_path}/signatures/sig/{rnd_sig}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sig file") f.close() sig_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIG, self.rnd_mapset_name, ctypes.byref(sig_list)) shutil.rmtree(sig_dir) self.assertEqual(ret, 1) val = utils.decode(sig_list[0]) self.assertEqual(val, f"{rnd_sig}@{self.rnd_mapset_name}") I_free_signatures_list(ret, ctypes.byref(sig_list)) # SigSet type # SigSet equals sig. Just testing branching inside. rnd_sigset = tempname(10) sig_dir = f"{self.rnd_mapset_path}/signatures/sigset/{rnd_sigset}" os.makedirs(sig_dir) self.sigdirs.append(sig_dir) f = open(f"{sig_dir}/sig", "w") f.write("A sigset file") f.close() sigset_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIGSET, self.rnd_mapset_name, ctypes.byref(sigset_list)) shutil.rmtree(sig_dir) self.assertEqual(ret, 1) val = utils.decode(sigset_list[0]) self.assertEqual(val, f"{rnd_sigset}@{self.rnd_mapset_name}") I_free_signatures_list(ret, ctypes.byref(sigset_list))
def setUpClass(cls): cls.list_ptr = ctypes.POINTER(ctypes.c_char_p) cls.mpath = utils.decode(G_mapset_path()) cls.mapset_name = Mapset().name cls.sigdirs = [] # As signatures are created directly not via signature creation # tools, we must ensure signature directories exist os.makedirs(f"{cls.mpath}/signatures/sig/", exist_ok=True) os.makedirs(f"{cls.mpath}/signatures/sigset/", exist_ok=True) # A mapset with a random name cls.rnd_mapset_name = tempname(10) G_make_mapset(None, None, cls.rnd_mapset_name) cls.rnd_mapset_path = (cls.mpath.rsplit("/", maxsplit=1)[0] + "/" + cls.rnd_mapset_name) os.makedirs(f"{cls.rnd_mapset_path}/signatures/sig/") os.makedirs(f"{cls.rnd_mapset_path}/signatures/sigset/")
def test_success_unqualified_sigset(self): dst = tempname(10) ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, dst, self.mapset_name) self.assertFalse(ret) ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, self.src_sigset, self.src_mapset_name) self.assertTrue(ret) ret = I_signatures_copy(I_SIGFILE_TYPE_SIGSET, self.src_sigset, self.src_mapset_name, dst) self.sigdirs.append(f"{self.mpath}/signatures/sigset/{dst}") self.assertEqual(ret, 0) ret = I_find_signature(I_SIGFILE_TYPE_SIGSET, dst, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) self.assertTrue( os.path.isfile(f"{self.mpath}/signatures/sigset/{dst}/sig"))
def test_broken_signature_v1_norgb(self): """Test reading back signature file (v1) should fail due to single semantic label exceeding maximum length""" # Create signature struct So = Signature() I_init_signatures(ctypes.byref(So), 1) self.assertEqual(So.nbands, 1) sig_count = I_new_signature(ctypes.byref(So)) self.assertEqual(sig_count, 1) # Fill signatures struct with data So.title = b"Signature title" # len(tempname(251)) == 255 So.semantic_labels[0] = ctypes.create_string_buffer( tempname(251).encode()) So.sig[0].status = 1 So.sig[0].have_color = 0 So.sig[0].npoints = 42 So.sig[0].desc = b"my label" So.sig[0].mean[0] = 2.5 So.sig[0].var[0][0] = 0.7 # Write signatures to file p_new_sigfile = I_fopen_signature_file_new(self.sig_name) sig_stat = os.stat(f"{self.sig_dir}/sig") self.assertTrue(stat.S_ISREG(sig_stat.st_mode)) I_write_signatures(p_new_sigfile, ctypes.byref(So)) self.libc.fclose(p_new_sigfile) # Read back from signatures file Sn = Signature() p_old_sigfile = I_fopen_signature_file_old(self.sig_name) ret = I_read_signatures(p_old_sigfile, ctypes.byref(Sn)) self.assertEqual(ret, -1) So.semantic_labels[0] = None I_free_signatures(ctypes.byref(So)) I_free_signatures(ctypes.byref(Sn))
def test_success_fq_sig(self): dst_name = tempname(10) self.sigdirs.append(f"{self.mpath}/signatures/sig/{dst_name}") dst = dst_name + "@" + self.mapset_name ret = I_find_signature(I_SIGFILE_TYPE_SIG, dst, self.mapset_name) self.assertFalse(ret) ret = I_find_signature(I_SIGFILE_TYPE_SIG, self.src_sig, self.src_mapset_name) self.assertTrue(ret) ret = I_signatures_copy( I_SIGFILE_TYPE_SIG, self.src_sig + "@" + self.src_mapset_name, self.src_mapset_name, dst, ) self.assertEqual(ret, 0) ret = I_find_signature(I_SIGFILE_TYPE_SIG, dst, self.mapset_name) self.assertTrue(ret) ms = utils.decode(ret) self.assertEqual(ms, self.mapset_name) self.assertTrue( os.path.isfile(f"{self.mpath}/signatures/sig/{dst_name}/sig"))
def test_read_fail_sigset_v1_one_label(self): """Reading back should fail as semantic label length exceeds limit""" # Create signature struct So = SigSet() I_InitSigSet(ctypes.byref(So), 1) self.assertEqual(So.nbands, 1) I_NewClassSig(ctypes.byref(So)) self.assertEqual(So.nclasses, 1) I_NewSubSig(ctypes.byref(So), ctypes.byref(So.ClassSig[0])) self.assertEqual(So.ClassSig[0].nsubclasses, 1) # Fill sigset struct with data So.title = ReturnString("Signature title") So.semantic_labels[0] = ctypes.create_string_buffer(tempname(252).encode()) So.ClassSig[0].used = 1 So.ClassSig[0].classnum = 2 So.ClassSig[0].title = ReturnString("1st class") So.ClassSig[0].type = 1 So.ClassSig[0].SubSig[0].pi = 3.14 So.ClassSig[0].SubSig[0].means[0] = 42.42 So.ClassSig[0].SubSig[0].R[0][0] = 69.69 # Write signatures to file p_new_sigfile = I_fopen_sigset_file_new(self.sig_name) sig_stat = os.stat(f"{self.sig_dir}/sig") self.assertTrue(stat.S_ISREG(sig_stat.st_mode)) I_WriteSigSet(p_new_sigfile, ctypes.byref(So)) self.libc.fclose(p_new_sigfile) # Read back from signatures file Sn = SigSet() I_InitSigSet(ctypes.byref(So), 0) p_old_sigfile = I_fopen_sigset_file_old(self.sig_name) ret = I_ReadSigSet(p_old_sigfile, ctypes.byref(Sn)) self.assertEqual(ret, -1)
def test_sig_does_not_exist(self): ret = I_signatures_copy(I_SIGFILE_TYPE_SIG, tempname(10), self.mapset_name, tempname(10)) self.assertEqual(ret, 1)
def test_rename_to_wrong_mapset(self): rnd_name = "{0}@{0}".format(tempname(10)) ret = I_signatures_rename(I_SIGFILE_TYPE_SIG, tempname(10), rnd_name) self.assertEqual(ret, 1)
def test_I_fopen_signature_file_old_fail(self): sigfile = I_fopen_signature_file_old(tempname(10)) self.assertFalse(sigfile)
def setUpClass(cls): cls.libc = ctypes.cdll.LoadLibrary(ctypes.util.find_library("c")) cls.mpath = utils.decode(G_mapset_path()) cls.mapset_name = Mapset().name cls.sig_name = tempname(10) cls.sig_dir = f"{cls.mpath}/signatures/sig/{cls.sig_name}"
def test_sigset_does_not_exist(self): ret = I_signatures_rename(I_SIGFILE_TYPE_SIGSET, tempname(10), tempname(10)) self.assertEqual(ret, 1)
def test_multiple_sigs(self): # Should result into a multiple sigs returned # Sig type rnd_sig1 = tempname(10) sig_dir1 = f"{self.rnd_mapset_path}/signatures/sig/{rnd_sig1}" os.makedirs(sig_dir1) self.sigdirs.append(sig_dir1) f = open(f"{sig_dir1}/sig", "w") f.write("A sig file") f.close() rnd_sig2 = tempname(10) sig_dir2 = f"{self.rnd_mapset_path}/signatures/sig/{rnd_sig2}" os.makedirs(sig_dir2) self.sigdirs.append(sig_dir2) f = open(f"{sig_dir2}/sig", "w") f.write("A sig file") f.close() # POINTER(POINTER(c_char)) sig_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIG, self.rnd_mapset_name, ctypes.byref(sig_list)) shutil.rmtree(sig_dir1) shutil.rmtree(sig_dir2) self.assertEqual(ret, 2) golden = ( f"{rnd_sig1}@{self.rnd_mapset_name}", f"{rnd_sig2}@{self.rnd_mapset_name}", ) self.assertIn(utils.decode(sig_list[0]), golden) self.assertIn(utils.decode(sig_list[1]), golden) I_free_signatures_list(ret, ctypes.byref(sig_list)) # SigSet type rnd_sigset1 = tempname(10) sig_dir1 = f"{self.rnd_mapset_path}/signatures/sigset/{rnd_sigset1}" os.makedirs(sig_dir1) self.sigdirs.append(sig_dir1) f = open(f"{sig_dir1}/sig", "w") f.write("A sigset file") f.close() rnd_sigset2 = tempname(10) sig_dir2 = f"{self.rnd_mapset_path}/signatures/sigset/{rnd_sigset2}" os.makedirs(sig_dir2) self.sigdirs.append(sig_dir2) f = open(f"{sig_dir2}/sig", "w") f.write("A sigset file") f.close() sigset_list = self.list_ptr() ret = I_signatures_list_by_type(I_SIGFILE_TYPE_SIGSET, self.rnd_mapset_name, ctypes.byref(sigset_list)) shutil.rmtree(sig_dir1) shutil.rmtree(sig_dir2) self.assertEqual(ret, 2) golden = ( f"{rnd_sigset1}@{self.rnd_mapset_name}", f"{rnd_sigset2}@{self.rnd_mapset_name}", ) self.assertIn(utils.decode(sigset_list[0]), golden) self.assertIn(utils.decode(sigset_list[1]), golden) I_free_signatures_list(ret, ctypes.byref(sigset_list))