derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

misc,python: Run pre-commit run --all-files

Browse Source 
Applies the `pyupgrade` hook to all files in the repo.

Change-Id: I9879c634a65c5fcaa9567c63bc5977ff97d5d3bf
This commit is contained in:
Bobby R. Bruce
2023-10-09 13:40:03 -07:00
parent 83af4525ce
commit 298119e402
188 changed files with 741 additions and 779 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
tests/pyunit/stdlib/pyunit_looppoint.py
View File

@@ -47,21 +47,21 @@ class LooppointRegionPCTestSuite(unittest.TestCase):
def test_construction_with_relative(self) -> None:
region_pc = LooppointRegionPC(pc=444, globl=65, relative=454)
self.assertEquals(444, region_pc.get_pc())
self.assertEquals(65, region_pc.get_global())
self.assertEquals(454, region_pc.get_relative())
self.assertEqual(444, region_pc.get_pc())
self.assertEqual(65, region_pc.get_global())
self.assertEqual(454, region_pc.get_relative())
def test_construction_without_relative(self) -> None:
region_pc = LooppointRegionPC(pc=43454, globl=653434)
self.assertEquals(43454, region_pc.get_pc())
self.assertEquals(653434, region_pc.get_global())
self.assertEqual(43454, region_pc.get_pc())
self.assertEqual(653434, region_pc.get_global())
self.assertIsNone(region_pc.get_relative())
def test_get_pc_count_pair(self) -> None:
region_pc = LooppointRegionPC(pc=1, globl=2)
expected = PcCountPair(1, 2)
self.assertEquals(expected, region_pc.get_pc_count_pair())
self.assertEqual(expected, region_pc.get_pc_count_pair())
def update_relative_count(self) -> None:
pass # Not really sure what to do here...
@@ -70,23 +70,23 @@ class LooppointRegionPCTestSuite(unittest.TestCase):
region_pc = LooppointRegionPC(pc=100, globl=200, relative=300)
json_contents = region_pc.to_json()
self.assertEquals(3, len(json_contents))
self.assertEqual(3, len(json_contents))
self.assertTrue("pc" in json_contents)
self.assertEquals(100, json_contents["pc"])
self.assertEqual(100, json_contents["pc"])
self.assertTrue("global" in json_contents)
self.assertEquals(200, json_contents["global"])
self.assertEqual(200, json_contents["global"])
self.assertTrue("relative" in json_contents)
self.assertEquals(300, json_contents["relative"])
self.assertEqual(300, json_contents["relative"])
def test_to_json_without_relative(self) -> None:
region_pc = LooppointRegionPC(pc=1111, globl=2222)
json_contents = region_pc.to_json()
self.assertEquals(2, len(json_contents))
self.assertEqual(2, len(json_contents))
self.assertTrue("pc" in json_contents)
self.assertEquals(1111, json_contents["pc"])
self.assertEqual(1111, json_contents["pc"])
self.assertTrue("global" in json_contents)
self.assertEquals(2222, json_contents["global"])
self.assertEqual(2222, json_contents["global"])
self.assertFalse("relative" in json_contents)
@@ -98,8 +98,8 @@ class LooppointRegionWarmupTestSuite(unittest.TestCase):
start=PcCountPair(123, 456), end=PcCountPair(789, 1011)
)
self.assertEquals(PcCountPair(123, 456), region_warmup.get_start())
self.assertEquals(PcCountPair(789, 1011), region_warmup.get_end())
self.assertEqual(PcCountPair(123, 456), region_warmup.get_start())
self.assertEqual(PcCountPair(789, 1011), region_warmup.get_end())
def test_get_pc_count_pairs(self) -> None:
region_warmup = LooppointRegionWarmup(
@@ -107,9 +107,9 @@ class LooppointRegionWarmupTestSuite(unittest.TestCase):
)
output = region_warmup.get_pc_count_pairs()
self.assertEquals(2, len(output))
self.assertEquals(PcCountPair(1, 1), output[0])
self.assertEquals(PcCountPair(2, 2), output[1])
self.assertEqual(2, len(output))
self.assertEqual(PcCountPair(1, 1), output[0])
self.assertEqual(PcCountPair(2, 2), output[1])
def test_to_json(self) -> None:
region_warmup = LooppointRegionWarmup(
@@ -135,14 +135,14 @@ class LooppointSimulationTestSuite(unittest.TestCase):
sim_start = sim.get_start()
self.assertEquals(444, sim_start.get_pc())
self.assertEquals(65, sim_start.get_global())
self.assertEquals(454, sim_start.get_relative())
self.assertEqual(444, sim_start.get_pc())
self.assertEqual(65, sim_start.get_global())
self.assertEqual(454, sim_start.get_relative())
sim_end = sim.get_end()
self.assertEquals(555, sim_end.get_pc())
self.assertEquals(699, sim_end.get_global())
self.assertEqual(555, sim_end.get_pc())
self.assertEqual(699, sim_end.get_global())
self.assertIsNone(sim_end.get_relative())
def test_get_pc_count_pairs(self) -> None:
@@ -152,9 +152,9 @@ class LooppointSimulationTestSuite(unittest.TestCase):
)
sim_pc_count_pairs = sim.get_pc_count_pairs()
self.assertEquals(2, len(sim_pc_count_pairs))
self.assertEquals(PcCountPair(56, 45), sim_pc_count_pairs[0])
self.assertEquals(PcCountPair(23, 12), sim_pc_count_pairs[1])
self.assertEqual(2, len(sim_pc_count_pairs))
self.assertEqual(PcCountPair(56, 45), sim_pc_count_pairs[0])
self.assertEqual(PcCountPair(23, 12), sim_pc_count_pairs[1])
def test_get_json(self) -> None:
sim = LooppointSimulation(
@@ -193,7 +193,7 @@ class LooppointRegionTestSuite(unittest.TestCase):
self.assertTrue(
isinstance(region.get_simulation(), LooppointSimulation)
)
self.assertEquals(5.6, region.get_multiplier())
self.assertEqual(5.6, region.get_multiplier())
self.assertIsNotNone(region.get_warmup())
self.assertTrue(isinstance(region.get_warmup(), LooppointRegionWarmup))
@@ -209,7 +209,7 @@ class LooppointRegionTestSuite(unittest.TestCase):
self.assertTrue(
isinstance(region.get_simulation(), LooppointSimulation)
)
self.assertEquals(5444.4, region.get_multiplier())
self.assertEqual(5444.4, region.get_multiplier())
self.assertIsNone(region.get_warmup())
def test_get_pc_count_pairs_with_warmup(self):
@@ -225,11 +225,11 @@ class LooppointRegionTestSuite(unittest.TestCase):
)
pc_count_pairs = region.get_pc_count_pairs()
self.assertEquals(4, len(pc_count_pairs))
self.assertEquals(PcCountPair(1, 2), pc_count_pairs[0])
self.assertEquals(PcCountPair(6, 7), pc_count_pairs[1])
self.assertEquals(PcCountPair(100, 200), pc_count_pairs[2])
self.assertEquals(PcCountPair(101, 202), pc_count_pairs[3])
self.assertEqual(4, len(pc_count_pairs))
self.assertEqual(PcCountPair(1, 2), pc_count_pairs[0])
self.assertEqual(PcCountPair(6, 7), pc_count_pairs[1])
self.assertEqual(PcCountPair(100, 200), pc_count_pairs[2])
self.assertEqual(PcCountPair(101, 202), pc_count_pairs[3])
def test_get_pc_count_pairs_without_warmup(self):
region = LooppointRegion(
@@ -242,9 +242,9 @@ class LooppointRegionTestSuite(unittest.TestCase):
pc_count_pairs = region.get_pc_count_pairs()
self.assertEquals(2, len(pc_count_pairs))
self.assertEquals(PcCountPair(56, 2345), pc_count_pairs[0])
self.assertEquals(PcCountPair(645, 457), pc_count_pairs[1])
self.assertEqual(2, len(pc_count_pairs))
self.assertEqual(PcCountPair(56, 2345), pc_count_pairs[0])
self.assertEqual(PcCountPair(645, 457), pc_count_pairs[1])
class LooppointTestSuite(unittest.TestCase):
@@ -276,11 +276,11 @@ class LooppointTestSuite(unittest.TestCase):
}
)
self.assertEquals(2, len(looppoint.get_regions()))
self.assertEqual(2, len(looppoint.get_regions()))
self.assertTrue(1 in looppoint.get_regions())
self.assertEquals(region1, looppoint.get_regions()[1])
self.assertEqual(region1, looppoint.get_regions()[1])
self.assertTrue(3 in looppoint.get_regions())
self.assertEquals(region2, looppoint.get_regions()[3])
self.assertEqual(region2, looppoint.get_regions()[3])
def test_get_targets(self):
region1 = LooppointRegion(
@@ -309,13 +309,13 @@ class LooppointTestSuite(unittest.TestCase):
)
targets = looppoint.get_targets()
self.assertEquals(6, len(targets))
self.assertEquals(PcCountPair(56, 2345), targets[0])
self.assertEquals(PcCountPair(645, 457), targets[1])
self.assertEquals(PcCountPair(67, 254), targets[2])
self.assertEquals(PcCountPair(64554, 7454), targets[3])
self.assertEquals(PcCountPair(100, 200), targets[4])
self.assertEquals(PcCountPair(101, 202), targets[5])
self.assertEqual(6, len(targets))
self.assertEqual(PcCountPair(56, 2345), targets[0])
self.assertEqual(PcCountPair(645, 457), targets[1])
self.assertEqual(PcCountPair(67, 254), targets[2])
self.assertEqual(PcCountPair(64554, 7454), targets[3])
self.assertEqual(PcCountPair(100, 200), targets[4])
self.assertEqual(PcCountPair(101, 202), targets[5])
def test_get_region_start_id_map(self):
region1 = LooppointRegion(
@@ -345,15 +345,15 @@ class LooppointTestSuite(unittest.TestCase):
region_start_id_map = looppoint.get_region_start_id_map()
self.assertEquals(2, len(region_start_id_map))
self.assertEqual(2, len(region_start_id_map))
# The start of region1.
self.assertTrue(PcCountPair(56, 2345) in region_start_id_map)
self.assertEquals(1, region_start_id_map[PcCountPair(56, 2345)])
self.assertEqual(1, region_start_id_map[PcCountPair(56, 2345)])
# The start of region2. Since this has a warmup, it's the warmup.
self.assertTrue(PcCountPair(100, 200) in region_start_id_map)
self.assertEquals(3, region_start_id_map[PcCountPair(100, 200)])
self.assertEqual(3, region_start_id_map[PcCountPair(100, 200)])
def test_to_json(self) -> None:
region1 = LooppointRegion(
@@ -440,60 +440,60 @@ class LooppointCSVLoaderTestSuite(unittest.TestCase):
)
regions = looppoint.get_regions()
self.assertEquals(3, len(regions))
self.assertEqual(3, len(regions))
region1 = regions[1]
self.assertEquals(4.0, region1.get_multiplier())
self.assertEqual(4.0, region1.get_multiplier())
region1start = region1.get_simulation().get_start()
self.assertEquals(0x4069D0, region1start.get_pc())
self.assertEquals(211076617, region1start.get_global())
self.assertEqual(0x4069D0, region1start.get_pc())
self.assertEqual(211076617, region1start.get_global())
self.assertIsNone(region1start.get_relative())
region1end = region1.get_simulation().get_end()
self.assertEquals(0x4069D0, region1end.get_pc())
self.assertEquals(219060252, region1end.get_global())
self.assertEqual(0x4069D0, region1end.get_pc())
self.assertEqual(219060252, region1end.get_global())
self.assertIsNotNone(region1end.get_relative())
self.assertEquals(1060676, region1end.get_relative())
self.assertEqual(1060676, region1end.get_relative())
self.assertIsNone(region1.get_warmup())
region2 = regions[2]
self.assertEquals(5.001, region2.get_multiplier())
self.assertEqual(5.001, region2.get_multiplier())
region2start = region2.get_simulation().get_start()
self.assertEquals(0x4069D0, region2start.get_pc())
self.assertEquals(407294228, region2start.get_global())
self.assertEqual(0x4069D0, region2start.get_pc())
self.assertEqual(407294228, region2start.get_global())
self.assertIsNone(region2start.get_relative())
region2end = region2.get_simulation().get_end()
self.assertEquals(0x4069D0, region2end.get_pc())
self.assertEquals(415282447, region2end.get_global())
self.assertEqual(0x4069D0, region2end.get_pc())
self.assertEqual(415282447, region2end.get_global())
self.assertIsNotNone(region2end.get_relative())
self.assertEquals(1035231, region2end.get_relative())
self.assertEqual(1035231, region2end.get_relative())
region2warmup = region2.get_warmup()
self.assertIsNotNone(region2warmup)
self.assertEquals(
self.assertEqual(
PcCountPair(0x406880, 48111518), region2warmup.get_start()
)
self.assertEquals(
self.assertEqual(
PcCountPair(0x4069D0, 407294228), region2warmup.get_end()
)
region3 = regions[3]
self.assertEquals(4.0, region3.get_multiplier())
self.assertEqual(4.0, region3.get_multiplier())
region3start = region3.get_simulation().get_start()
self.assertEquals(0x4069D0, region3start.get_pc())
self.assertEquals(187978221, region3start.get_global())
self.assertEqual(0x4069D0, region3start.get_pc())
self.assertEqual(187978221, region3start.get_global())
self.assertIsNone(region3start.get_relative())
region3end = region3.get_simulation().get_end()
self.assertEquals(0x406880, region3end.get_pc())
self.assertEquals(23520614, region3end.get_global())
self.assertEqual(0x406880, region3end.get_pc())
self.assertEqual(23520614, region3end.get_global())
self.assertIsNotNone(region3end.get_relative())
self.assertEquals(144352, region3end.get_relative())
self.assertEqual(144352, region3end.get_relative())
self.assertIsNone(region3.get_warmup())
@@ -508,22 +508,22 @@ class LooppointCSVLoaderTestSuite(unittest.TestCase):
)
regions = looppoint.get_regions()
self.assertEquals(1, len(regions))
self.assertEqual(1, len(regions))
self.assertTrue(1 in regions)
region1 = regions[1]
self.assertEquals(4.0, region1.get_multiplier())
self.assertEqual(4.0, region1.get_multiplier())
region1start = region1.get_simulation().get_start()
self.assertEquals(0x4069D0, region1start.get_pc())
self.assertEquals(211076617, region1start.get_global())
self.assertEqual(0x4069D0, region1start.get_pc())
self.assertEqual(211076617, region1start.get_global())
self.assertIsNone(region1start.get_relative())
region1end = region1.get_simulation().get_end()
self.assertEquals(0x4069D0, region1end.get_pc())
self.assertEquals(219060252, region1end.get_global())
self.assertEqual(0x4069D0, region1end.get_pc())
self.assertEqual(219060252, region1end.get_global())
self.assertIsNotNone(region1end.get_relative())
self.assertEquals(1060676, region1end.get_relative())
self.assertEqual(1060676, region1end.get_relative())
self.assertIsNone(region1.get_warmup())
@@ -541,31 +541,31 @@ class LooppointJsonLoaderTestSuite(unittest.TestCase):
region_id="1",
)
self.assertEquals(1, len(looppoint.get_regions()))
self.assertEqual(1, len(looppoint.get_regions()))
self.assertTrue("1" in looppoint.get_regions())
region = looppoint.get_regions()["1"]
self.assertEquals(4.0, region.get_multiplier())
self.assertEqual(4.0, region.get_multiplier())
region_start = region.get_simulation().get_start()
self.assertEquals(4221392, region_start.get_pc())
self.assertEquals(211076617, region_start.get_global())
self.assertEqual(4221392, region_start.get_pc())
self.assertEqual(211076617, region_start.get_global())
self.assertIsNotNone(region_start.get_relative())
self.assertEquals(15326617, region_start.get_relative())
self.assertEqual(15326617, region_start.get_relative())
region_end = region.get_simulation().get_end()
self.assertEquals(4221392, region_end.get_pc())
self.assertEquals(219060252, region_end.get_global())
self.assertEqual(4221392, region_end.get_pc())
self.assertEqual(219060252, region_end.get_global())
self.assertIsNotNone(region_end.get_relative())
self.assertEquals(23310252, region_end.get_relative())
self.assertEqual(23310252, region_end.get_relative())
region_warmup = region.get_warmup()
self.assertIsNotNone(region_warmup)
self.assertEquals(
self.assertEqual(
PcCountPair(4221056, 23520614), region_warmup.get_start()
)
self.assertEquals(
self.assertEqual(
PcCountPair(4221392, 211076617), region_warmup.get_end()
)
@@ -579,20 +579,20 @@ class LooppointJsonLoaderTestSuite(unittest.TestCase):
region_id="2",
)
self.assertEquals(1, len(looppoint.get_regions()))
self.assertEqual(1, len(looppoint.get_regions()))
self.assertTrue("2" in looppoint.get_regions())
region = looppoint.get_regions()["2"]
self.assertEquals(5.001, region.get_multiplier())
self.assertEqual(5.001, region.get_multiplier())
region_start = region.get_simulation().get_start()
self.assertEquals(4221392, region_start.get_pc())
self.assertEquals(407294228, region_start.get_global())
self.assertEqual(4221392, region_start.get_pc())
self.assertEqual(407294228, region_start.get_global())
self.assertIsNone(region_start.get_relative())
region_end = region.get_simulation().get_end()
self.assertEquals(4221392, region_end.get_pc())
self.assertEquals(415282447, region_end.get_global())
self.assertEqual(4221392, region_end.get_pc())
self.assertEqual(415282447, region_end.get_global())
self.assertIsNone(region_end.get_relative())
region_warmup = region.get_warmup()

4
tests/pyunit/stdlib/resources/pyunit_client_wrapper_checks.py
View File

@@ -67,12 +67,12 @@ mock_config_combined["sources"]["baba"] = mock_config_json["sources"]["baba"]
mock_json = {}
with open(Path(__file__).parent / "refs/mongo-mock.json", "r") as f:
with open(Path(__file__).parent / "refs/mongo-mock.json") as f:
mock_json = json.load(f)
duplicate_mock_json = {}
with open(Path(__file__).parent / "refs/mongo-dup-mock.json", "r") as f:
with open(Path(__file__).parent / "refs/mongo-dup-mock.json") as f:
duplicate_mock_json = json.load(f)

12
tests/pyunit/stdlib/resources/pyunit_json_client_checks.py
View File

@@ -148,16 +148,16 @@ class JSONClientTestSuite(unittest.TestCase):
"create_temp_resources_json" has been loaded correctly into a Python
dictionary.
"""
self.assertEquals(4, len(json))
self.assertEqual(4, len(json))
self.assertTrue("id" in json[0])
self.assertEquals("this-is-a-test-resource", json[0]["id"])
self.assertEquals("binary", json[0]["category"])
self.assertEqual("this-is-a-test-resource", json[0]["id"])
self.assertEqual("binary", json[0]["category"])
self.assertTrue("id" in json[1])
self.assertEquals("this-is-a-test-resource", json[1]["id"])
self.assertEqual("this-is-a-test-resource", json[1]["id"])
self.assertTrue("id" in json[2])
self.assertEquals("test-version", json[2]["id"])
self.assertEqual("test-version", json[2]["id"])
self.assertTrue("id" in json[3])
self.assertEquals("test-version", json[3]["id"])
self.assertEqual("test-version", json[3]["id"])
def test_get_resources_json_at_path(self) -> None:
# Tests JSONClient.get_resources_json()

8
tests/pyunit/stdlib/resources/pyunit_md5_utils_check.py
View File

@@ -46,7 +46,7 @@ class MD5FileTestSuite(unittest.TestCase):
md5 = md5_file(Path(file.name))
os.remove(file.name)
self.assertEquals("b113b29fce251f2023066c3fda2ec9dd", md5)
self.assertEqual("b113b29fce251f2023066c3fda2ec9dd", md5)
def test_identicalFilesIdenticalMd5(self) -> None:
# This test ensures that two files with exactly the same contents have
@@ -68,7 +68,7 @@ class MD5FileTestSuite(unittest.TestCase):
os.remove(file.name)
self.assertEquals(first_file_md5, second_file_md5)
self.assertEqual(first_file_md5, second_file_md5)
class MD5DirTestSuite(unittest.TestCase):
@@ -98,7 +98,7 @@ class MD5DirTestSuite(unittest.TestCase):
md5 = md5_dir(dir)
shutil.rmtree(dir)
self.assertEquals("ad5ac785de44c9fc2fe2798cab2d7b1a", md5)
self.assertEqual("ad5ac785de44c9fc2fe2798cab2d7b1a", md5)
def test_identicalDirsIdenticalMd5(self) -> None:
# This test ensures that two directories with exactly the same contents
@@ -112,4 +112,4 @@ class MD5DirTestSuite(unittest.TestCase):
second_md5 = md5_dir(dir2)
shutil.rmtree(dir2)
self.assertEquals(first_md5, second_md5)
self.assertEqual(first_md5, second_md5)

26
tests/pyunit/stdlib/resources/pyunit_obtain_resources_check.py
View File

@@ -78,13 +78,11 @@ class TestObtainResourcesCheck(unittest.TestCase):
resource_directory=self.get_resource_dir(),
gem5_version="develop",
)
self.assertEquals("1.7.0", resource.get_resource_version())
self.assertEqual("1.7.0", resource.get_resource_version())
self.assertIsInstance(resource, BinaryResource)
self.assertEquals(
"test description v1.7.0", resource.get_description()
)
self.assertEquals("src/test-source", resource.get_source())
self.assertEquals(ISA.ARM, resource.get_architecture())
self.assertEqual("test description v1.7.0", resource.get_description())
self.assertEqual("src/test-source", resource.get_source())
self.assertEqual(ISA.ARM, resource.get_architecture())
def test_obtain_resources_with_version_compatible(self):
resource = obtain_resource(
@@ -93,13 +91,13 @@ class TestObtainResourcesCheck(unittest.TestCase):
resource_version="1.5.0",
gem5_version="develop",
)
self.assertEquals("1.5.0", resource.get_resource_version())
self.assertEqual("1.5.0", resource.get_resource_version())
self.assertIsInstance(resource, BinaryResource)
self.assertEquals(
self.assertEqual(
"test description for 1.5.0", resource.get_description()
)
self.assertEquals("src/test-source", resource.get_source())
self.assertEquals(ISA.ARM, resource.get_architecture())
self.assertEqual("src/test-source", resource.get_source())
self.assertEqual(ISA.ARM, resource.get_architecture())
def test_obtain_resources_with_version_incompatible(self):
resource = None
@@ -117,13 +115,13 @@ class TestObtainResourcesCheck(unittest.TestCase):
resource_version="1.5.0",
gem5_version="develop",
)
self.assertEquals("1.5.0", resource.get_resource_version())
self.assertEqual("1.5.0", resource.get_resource_version())
self.assertIsInstance(resource, BinaryResource)
self.assertEquals(
self.assertEqual(
"test description for 1.5.0", resource.get_description()
)
self.assertEquals("src/test-source", resource.get_source())
self.assertEquals(ISA.ARM, resource.get_architecture())
self.assertEqual("src/test-source", resource.get_source())
self.assertEqual(ISA.ARM, resource.get_architecture())
def test_obtain_resources_no_version_invalid_id(self):
with self.assertRaises(Exception) as context:

54
tests/pyunit/stdlib/resources/pyunit_resource_specialization.py
View File

@@ -86,11 +86,11 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, BinaryResource)
self.assertEquals(
self.assertEqual(
"binary-example documentation.", resource.get_description()
)
self.assertEquals("src/simple", resource.get_source())
self.assertEquals(ISA.ARM, resource.get_architecture())
self.assertEqual("src/simple", resource.get_source())
self.assertEqual(ISA.ARM, resource.get_architecture())
def test_kernel_resource(self) -> None:
"""Tests the loading of a KernelResource."""
@@ -102,11 +102,11 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, KernelResource)
self.assertEquals(
self.assertEqual(
"kernel-example documentation.", resource.get_description()
)
self.assertEquals("src/linux-kernel", resource.get_source())
self.assertEquals(ISA.RISCV, resource.get_architecture())
self.assertEqual("src/linux-kernel", resource.get_source())
self.assertEqual(ISA.RISCV, resource.get_architecture())
def test_bootloader_resource(self) -> None:
"""Tests the loading of a BootloaderResource."""
@@ -118,7 +118,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, BootloaderResource)
self.assertEquals(
self.assertEqual(
"bootloader documentation.", resource.get_description()
)
self.assertIsNone(resource.get_source())
@@ -134,11 +134,11 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, DiskImageResource)
self.assertEquals(
self.assertEqual(
"disk-image documentation.", resource.get_description()
)
self.assertEquals("src/x86-ubuntu", resource.get_source())
self.assertEquals("1", resource.get_root_partition())
self.assertEqual("src/x86-ubuntu", resource.get_source())
self.assertEqual("1", resource.get_root_partition())
def test_checkpoint_resource(self) -> None:
"""Tests the loading of a CheckpointResource."""
@@ -150,7 +150,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, CheckpointResource)
self.assertEquals(
self.assertEqual(
"checkpoint-example documentation.", resource.get_description()
)
self.assertIsNone(resource.get_source())
@@ -178,14 +178,14 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, SimpointDirectoryResource)
self.assertEquals(
self.assertEqual(
"simpoint directory documentation.", resource.get_description()
)
self.assertIsNone(resource.get_source())
self.assertEquals(1000000, resource.get_simpoint_interval())
self.assertEquals(1000000, resource.get_warmup_interval())
self.assertEquals(
self.assertEqual(1000000, resource.get_simpoint_interval())
self.assertEqual(1000000, resource.get_warmup_interval())
self.assertEqual(
Path(
Path(self.get_resource_dir())
/ "simpoint-directory-example"
@@ -193,7 +193,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
),
resource.get_simpoint_file(),
)
self.assertEquals(
self.assertEqual(
Path(
Path(self.get_resource_dir())
/ "simpoint-directory-example"
@@ -201,7 +201,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
),
resource.get_weight_file(),
)
self.assertEquals("Example Workload", resource.get_workload_name())
self.assertEqual("Example Workload", resource.get_workload_name())
def test_simpoint_resource(self) -> None:
"""Tests the loading of a Simpoint resource."""
@@ -213,16 +213,14 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, SimpointResource)
self.assertEquals(
"simpoint documentation.", resource.get_description()
)
self.assertEqual("simpoint documentation.", resource.get_description())
self.assertIsNone(resource.get_source())
self.assertIsNone(resource.get_local_path())
self.assertEquals(1000000, resource.get_simpoint_interval())
self.assertEquals(23445, resource.get_warmup_interval())
self.assertEquals([2, 3, 4, 15], resource.get_simpoint_list())
self.assertEquals([0.1, 0.2, 0.4, 0.3], resource.get_weight_list())
self.assertEqual(1000000, resource.get_simpoint_interval())
self.assertEqual(23445, resource.get_warmup_interval())
self.assertEqual([2, 3, 4, 15], resource.get_simpoint_list())
self.assertEqual([0.1, 0.2, 0.4, 0.3], resource.get_weight_list())
def test_file_resource(self) -> None:
"""Tests the loading of a FileResource."""
@@ -247,7 +245,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, DirectoryResource)
self.assertEquals(
self.assertEqual(
"directory-example documentation.", resource.get_description()
)
self.assertIsNone(resource.get_source())
@@ -268,7 +266,7 @@ class ResourceSpecializationSuite(unittest.TestCase):
# LooppointCsvLoader.
self.assertIsInstance(resource, LooppointCsvLoader)
self.assertEquals(
self.assertEqual(
"A looppoint pinpoints csv file.", resource.get_description()
)
self.assertIsNone(resource.get_source())
@@ -287,10 +285,10 @@ class ResourceSpecializationSuite(unittest.TestCase):
self.assertIsInstance(resource, LooppointJsonResource)
self.assertIsInstance(resource, LooppointJsonLoader)
self.assertEquals(1, len(resource.get_regions()))
self.assertEqual(1, len(resource.get_regions()))
self.assertTrue("1" in resource.get_regions())
self.assertEquals(
self.assertEqual(
"A looppoint json file resource.", resource.get_description()
)
self.assertIsNone(resource.get_source())

2
tests/pyunit/stdlib/resources/pyunit_suite_checks.py
View File

@@ -150,7 +150,7 @@ class SuiteResourceTestSuite(unittest.TestCase):
"""
Tests the `list_input_groups` function.
"""
expected_input_groups = set(["testtag1", "testtag2", "testtag3"])
expected_input_groups = {"testtag1", "testtag2", "testtag3"}
self.assertEqual(self.suite.get_input_groups(), expected_input_groups)
@patch(

18
tests/pyunit/stdlib/resources/pyunit_workload_checks.py
View File

@@ -84,16 +84,16 @@ class CustomWorkloadTestSuite(unittest.TestCase):
parameters = self.custom_workload.get_parameters()
self.assertTrue(isinstance(parameters, Dict))
self.assertEquals(2, len(parameters))
self.assertEqual(2, len(parameters))
self.assertTrue("binary" in parameters)
self.assertTrue(isinstance(parameters["binary"], BinaryResource))
self.assertTrue("arguments" in parameters)
self.assertTrue(isinstance(parameters["arguments"], list))
self.assertEquals(2, len(parameters["arguments"]))
self.assertEquals("hello", parameters["arguments"][0])
self.assertEquals(6, parameters["arguments"][1])
self.assertEqual(2, len(parameters["arguments"]))
self.assertEqual("hello", parameters["arguments"][0])
self.assertEqual(6, parameters["arguments"][1])
def test_add_parameters(self) -> None:
# Tests `CustomWorkload.set_parameter` for the case where we add a new
@@ -102,7 +102,7 @@ class CustomWorkloadTestSuite(unittest.TestCase):
self.custom_workload.set_parameter("test_param", 10)
self.assertTrue("test_param" in self.custom_workload.get_parameters())
self.assertEquals(
self.assertEqual(
10, self.custom_workload.get_parameters()["test_param"]
)
@@ -117,7 +117,7 @@ class CustomWorkloadTestSuite(unittest.TestCase):
self.custom_workload.set_parameter("binary", "test")
self.assertTrue("binary" in self.custom_workload.get_parameters())
self.assertEquals(
self.assertEqual(
"test", self.custom_workload.get_parameters()["binary"]
)
@@ -141,7 +141,7 @@ class WorkloadTestSuite(unittest.TestCase):
def test_get_function_str(self) -> None:
# Tests `Resource.get_function_str`
self.assertEquals(
self.assertEqual(
"set_kernel_disk_workload", self.workload.get_function_str()
)
@@ -173,7 +173,7 @@ class WorkloadTestSuite(unittest.TestCase):
self.workload.set_parameter("test_param", 10)
self.assertTrue("test_param" in self.workload.get_parameters())
self.assertEquals(10, self.workload.get_parameters()["test_param"])
self.assertEqual(10, self.workload.get_parameters()["test_param"])
# Cleanup
del self.workload.get_parameters()["test_param"]
@@ -186,7 +186,7 @@ class WorkloadTestSuite(unittest.TestCase):
self.workload.set_parameter("readfile_contents", "test")
self.assertTrue("readfile_contents" in self.workload.get_parameters())
self.assertEquals(
self.assertEqual(
"test", self.workload.get_parameters()["readfile_contents"]
)