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

1
tests/gem5/cpu_tests/run.py
View File

@@ -1,4 +1,3 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2018 The Regents of the University of California
# All Rights Reserved.
#

26
tests/gem5/fixture.py
View File

@@ -58,16 +58,14 @@ from typing import Optional, List
class VariableFixture(Fixture):
def __init__(self, value=None, name=None):
super(VariableFixture, self).__init__(name=name)
super().__init__(name=name)
self.value = value
class TempdirFixture(Fixture):
def __init__(self):
self.path = None
super(TempdirFixture, self).__init__(
name=constants.tempdir_fixture_name
)
super().__init__(name=constants.tempdir_fixture_name)
def setup(self, testitem):
self.path = tempfile.mkdtemp(prefix="gem5out")
@@ -113,7 +111,7 @@ class UniqueFixture(Fixture):
if target in cls.fixtures:
obj = cls.fixtures[target]
else:
obj = super(UniqueFixture, cls).__new__(cls)
obj = super().__new__(cls)
obj.lock = threading.Lock()
obj.target = target
cls.fixtures[target] = obj
@@ -123,7 +121,7 @@ class UniqueFixture(Fixture):
with self.lock:
if hasattr(self, "_init_done"):
return
super(UniqueFixture, self).__init__(self, **kwargs)
super().__init__(self, **kwargs)
self._init(*args, **kwargs)
self._init_done = True
@@ -146,7 +144,7 @@ class SConsFixture(UniqueFixture):
"""
def __new__(cls, target):
obj = super(SConsFixture, cls).__new__(cls, target)
obj = super().__new__(cls, target)
return obj
def _setup(self, testitem):
@@ -195,7 +193,7 @@ class Gem5Fixture(SConsFixture):
if protocol:
target_dir += "_" + protocol
target = joinpath(target_dir, f"gem5.{variant}")
obj = super(Gem5Fixture, cls).__new__(cls, target)
obj = super().__new__(cls, target)
return obj
def _init(self, isa, variant, protocol=None):
@@ -220,14 +218,14 @@ class Gem5Fixture(SConsFixture):
class MakeFixture(Fixture):
def __init__(self, directory, *args, **kwargs):
name = f"make -C {directory}"
super(MakeFixture, self).__init__(
super().__init__(
build_once=True, lazy_init=False, name=name, *args, **kwargs
)
self.targets = []
self.directory = directory
def setup(self):
super(MakeFixture, self).setup()
super().setup()
targets = set(self.required_by)
command = ["make", "-C", self.directory]
command.extend([target.target for target in targets])
@@ -242,7 +240,7 @@ class MakeTarget(Fixture):
scons we need to know what invocation to attach to. If none given,
creates its own.
"""
super(MakeTarget, self).__init__(name=target, *args, **kwargs)
super().__init__(name=target, *args, **kwargs)
self.target = self.name
if make_fixture is None:
@@ -256,7 +254,7 @@ class MakeTarget(Fixture):
self.require(self.make_fixture)
def setup(self, testitem):
super(MakeTarget, self).setup()
super().setup()
self.make_fixture.setup()
return self
@@ -266,7 +264,7 @@ class TestProgram(MakeTarget):
make_dir = joinpath(config.bin_dir, program)
make_fixture = MakeFixture(make_dir)
target = joinpath("bin", isa, os, program)
super(TestProgram, self).__init__(target, make_fixture)
super().__init__(target, make_fixture)
self.path = joinpath(make_dir, target)
self.recompile = recompile
@@ -286,7 +284,7 @@ class DownloadedProgram(UniqueFixture):
def __new__(cls, url, path, filename, gzip_decompress=False):
target = joinpath(path, filename)
return super(DownloadedProgram, cls).__new__(cls, target)
return super().__new__(cls, target)
def _init(self, url, path, filename, gzip_decompress=False, **kwargs):
"""

4
tests/gem5/fs/linux/arm/configs/arm_generic.py
View File

@@ -56,7 +56,7 @@ class ArmSESystemUniprocessor(BaseSESystemUniprocessor):
"""
def __init__(self, **kwargs):
super(ArmSESystemUniprocessor, self).__init__(**kwargs)
super().__init__(**kwargs)
def create_caches_private(self, cpu):
# The atomic SE configurations do not use caches
@@ -67,7 +67,7 @@ class ArmSESystemUniprocessor(BaseSESystemUniprocessor):
)
class LinuxArmSystemBuilder(object):
class LinuxArmSystemBuilder:
"""Mix-in that implements create_system.
This mix-in is intended as a convenient way of adding an

16
tests/gem5/fs/linux/arm/configs/base_config.py
View File

@@ -46,7 +46,7 @@ from ruby import Ruby
_have_kvm_support = "BaseKvmCPU" in globals()
class BaseSystem(object, metaclass=ABCMeta):
class BaseSystem(metaclass=ABCMeta):
"""Base system builder.
This class provides some basic functionality for creating an ARM
@@ -254,10 +254,10 @@ class BaseSESystem(BaseSystem):
"""Basic syscall-emulation builder."""
def __init__(self, **kwargs):
super(BaseSESystem, self).__init__(**kwargs)
super().__init__(**kwargs)
def init_system(self, system):
super(BaseSESystem, self).init_system(system)
super().init_system(system)
def create_system(self):
if issubclass(self.mem_class, m5.objects.DRAMInterface):
@@ -291,7 +291,7 @@ class BaseSESystemUniprocessor(BaseSESystem):
"""
def __init__(self, **kwargs):
super(BaseSESystemUniprocessor, self).__init__(**kwargs)
super().__init__(**kwargs)
def create_caches_private(self, cpu):
# The atomic SE configurations do not use caches
@@ -311,10 +311,10 @@ class BaseFSSystem(BaseSystem):
"""Basic full system builder."""
def __init__(self, **kwargs):
super(BaseFSSystem, self).__init__(**kwargs)
super().__init__(**kwargs)
def init_system(self, system):
super(BaseFSSystem, self).init_system(system)
super().init_system(system)
if self.use_ruby:
# Connect the ruby io port to the PIO bus,
@@ -356,7 +356,7 @@ class BaseFSSystemUniprocessor(BaseFSSystem):
"""
def __init__(self, **kwargs):
super(BaseFSSystemUniprocessor, self).__init__(**kwargs)
super().__init__(**kwargs)
def create_caches_private(self, cpu):
cpu.addTwoLevelCacheHierarchy(
@@ -373,7 +373,7 @@ class BaseFSSwitcheroo(BaseFSSystem):
"""Uniprocessor system prepared for CPU switching"""
def __init__(self, cpu_classes, **kwargs):
super(BaseFSSwitcheroo, self).__init__(**kwargs)
super().__init__(**kwargs)
self.cpu_classes = tuple(cpu_classes)
def create_cpus(self, cpu_clk_domain):

2
tests/gem5/gem5_resources/configs/download_check.py
View File

@@ -91,7 +91,7 @@ if len(ids) == 0:
# We log all the errors as they occur then dump them at the end. This means we
# can be aware of all download errors in a single failure.
errors = str()
errors = ""
for id in ids:
if args.skip and id in args.skip:

8
tests/gem5/m5threads_test_atomic/caches.py
View File

@@ -51,7 +51,7 @@ class L1Cache(PrefetchCache):
writeback_clean = True
def __init__(self, options=None):
super(L1Cache, self).__init__(options)
super().__init__(options)
pass
def connectBus(self, bus):
@@ -71,7 +71,7 @@ class L1ICache(L1Cache):
size = "32kB"
def __init__(self, opts=None):
super(L1ICache, self).__init__(opts)
super().__init__(opts)
def connectCPU(self, cpu):
"""Connect this cache's port to a CPU icache port"""
@@ -85,7 +85,7 @@ class L1DCache(L1Cache):
size = "32kB"
def __init__(self, opts=None):
super(L1DCache, self).__init__(opts)
super().__init__(opts)
def connectCPU(self, cpu):
"""Connect this cache's port to a CPU dcache port"""
@@ -106,7 +106,7 @@ class L2Cache(PrefetchCache):
writeback_clean = True
def __init__(self, opts=None):
super(L2Cache, self).__init__(opts)
super().__init__(opts)
def connectCPUSideBus(self, bus):
self.cpu_side = bus.mem_side_ports

30
tests/gem5/verifier.py
View File

@@ -49,7 +49,7 @@ from testlib.configuration import constants
from testlib.helper import joinpath, diff_out_file
class Verifier(object):
class Verifier:
def __init__(self, fixtures=tuple()):
self.fixtures = fixtures
@@ -67,7 +67,7 @@ class Verifier(object):
class CheckH5StatsExist(Verifier):
def __init__(self, stats_file="stats.h5"):
super(CheckH5StatsExist, self).__init__()
super().__init__()
self.stats_file = stats_file
def test(self, params):
@@ -94,7 +94,7 @@ class MatchGoldStandard(Verifier):
either which will be ignored in 'standard' and test output files when
diffing.
"""
super(MatchGoldStandard, self).__init__()
super().__init__()
self.standard_filename = standard_filename
self.test_filename = test_filename
@@ -144,7 +144,7 @@ class DerivedGoldStandard(MatchGoldStandard):
self._generic_instance_warning(kwargs)
super(DerivedGoldStandard, self).__init__(
super().__init__(
standard_filename,
test_filename=self._file,
ignore_regex=ignore_regex,
@@ -155,7 +155,7 @@ class DerivedGoldStandard(MatchGoldStandard):
class MatchStdout(DerivedGoldStandard):
_file = constants.gem5_simulation_stdout
_default_ignore_regex = [
re.compile("^\s+$"), # Remove blank lines.
re.compile(r"^\s+$"), # Remove blank lines.
re.compile("^gem5 Simulator System"),
re.compile("^gem5 is copyrighted software"),
re.compile("^Redirecting (stdout|stderr) to"),
@@ -168,8 +168,8 @@ class MatchStdout(DerivedGoldStandard):
re.compile("^info: kernel located at:"),
re.compile("^info: Standard input is not a terminal"),
re.compile("^Couldn't unlink "),
re.compile("^Using GPU kernel code file\(s\) "),
re.compile("^.* not found locally\. Downloading"),
re.compile(r"^Using GPU kernel code file\(s\) "),
re.compile(r"^.* not found locally\. Downloading"),
re.compile("^Finished downloading"),
re.compile("^info: Using default config"),
]
@@ -218,12 +218,12 @@ class MatchFileRegex(Verifier):
"""
def __init__(self, regex, filenames):
super(MatchFileRegex, self).__init__()
super().__init__()
self.regex = _iterable_regex(regex)
self.filenames = filenames
def parse_file(self, fname):
with open(fname, "r") as file_:
with open(fname) as file_:
for line in file_:
for regex in self.regex:
if re.match(regex, line):
@@ -252,7 +252,7 @@ class MatchRegex(MatchFileRegex):
filenames.append(constants.gem5_simulation_stdout)
if match_stderr:
filenames.append(constants.gem5_simulation_stderr)
super(MatchRegex, self).__init__(regex, filenames)
super().__init__(regex, filenames)
class NoMatchRegex(MatchRegex):
@@ -261,7 +261,7 @@ class NoMatchRegex(MatchRegex):
"""
def __init__(self, regex, match_stderr=True, match_stdout=True):
super(NoMatchRegex, self).__init__(regex, match_stderr, match_stdout)
super().__init__(regex, match_stderr, match_stdout)
def test(self, params):
fixtures = params.fixtures
@@ -290,7 +290,7 @@ class MatchJSONStats(Verifier):
:param test_name_in_m5out: True if the 'test_name' dir is to found in
the `m5.options.outdir`.
"""
super(MatchJSONStats, self).__init__()
super().__init__()
self.truth_name = truth_name
self.test_name = test_name
self.test_name_in_outdir = test_name_in_outdir
@@ -318,13 +318,13 @@ class MatchJSONStats(Verifier):
test_util.fail(err)
def test(self, params):
trusted_file = open(self.truth_name, "r")
trusted_file = open(self.truth_name)
if self.test_name_in_outdir:
fixtures = params.fixtures
tempdir = fixtures[constants.tempdir_fixture_name].path
test_file = open(joinpath(tempdir, self.test_name), "r")
test_file = open(joinpath(tempdir, self.test_name))
else:
test_file = open(self.test_name, "r")
test_file = open(self.test_name)
return self._compare_stats(trusted_file, test_file)

20
tests/pyunit/pyunit_jsonserializable_check.py
View File

@@ -54,18 +54,18 @@ class JsonSerializableTestSuite(unittest.TestCase):
obj_json = obj.to_json()
self.assertTrue("child_1" in obj_json)
self.assertTrue("stat1" in obj_json["child_1"])
self.assertEquals(2, obj_json["child_1"]["stat1"])
self.assertEqual(2, obj_json["child_1"]["stat1"])
self.assertTrue("stat2" in obj_json["child_1"])
self.assertEquals("3", obj_json["child_1"]["stat2"])
self.assertEqual("3", obj_json["child_1"]["stat2"])
self.assertTrue("child_list" in obj_json)
self.assertEquals(2, len(obj_json["child_list"]))
self.assertEqual(2, len(obj_json["child_list"]))
self.assertTrue("stat1" in obj_json["child_list"][0])
self.assertEqual("hello", obj_json["child_list"][0]["stat1"])
self.assertTrue("list_stat2" in obj_json["child_list"][1])
self.assertEquals(6, len(obj_json["child_list"][1]["list_stat2"]))
self.assertEquals("1", obj_json["child_list"][1]["list_stat2"][0])
self.assertEquals(2, obj_json["child_list"][1]["list_stat2"][1])
self.assertEquals("3", obj_json["child_list"][1]["list_stat2"][2])
self.assertEquals(4, obj_json["child_list"][1]["list_stat2"][3])
self.assertEquals(5.2, obj_json["child_list"][1]["list_stat2"][4])
self.assertEquals(None, obj_json["child_list"][1]["list_stat2"][5])
self.assertEqual(6, len(obj_json["child_list"][1]["list_stat2"]))
self.assertEqual("1", obj_json["child_list"][1]["list_stat2"][0])
self.assertEqual(2, obj_json["child_list"][1]["list_stat2"][1])
self.assertEqual("3", obj_json["child_list"][1]["list_stat2"][2])
self.assertEqual(4, obj_json["child_list"][1]["list_stat2"][3])
self.assertEqual(5.2, obj_json["child_list"][1]["list_stat2"][4])
self.assertEqual(None, obj_json["child_list"][1]["list_stat2"][5])

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"]
)

2
tests/run.py
View File

@@ -189,7 +189,7 @@ def run_config(config, argv=None):
src_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../"))
abs_path = joinpath(src_root, config)
code = compile(open(abs_path, "r").read(), abs_path, "exec")
code = compile(open(abs_path).read(), abs_path, "exec")
scope = {"__file__": config, "__name__": "__m5_main__"}
# Set the working directory in case we are executing from