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

tests: fix persistence issue in pyunit tests (#1070)

Browse Source 
- Fixed patching/ mocking of functions and global variables to reset for
each test.
- Uncommented tests as they should pass now.
This commit is contained in:
Harshil Patel
2024-04-25 10:03:10 -07:00
committed by GitHub
parent 83e55743e1
commit d75afeabb1
5 changed files with 753 additions and 655 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -93,21 +93,36 @@ def mocked_requests_post(*args, **kwargs):
return MockResponse({"access_token": "test-token"}, 200) return MockResponse({"access_token": "test-token"}, 200)
if "/endpoint/data/v1/action/find" in args[0].full_url: if "/endpoint/data/v1/action/find" in args[0].full_url:
if data: if data:
if data["filter"]["id"] == "x86-ubuntu-18.04-img": if data["filter"]["$or"][0]["id"] == "x86-ubuntu-18.04-img":
if "resource_version" in data["filter"]["$or"][0]:
resource_version = data["filter"]["$or"][0][
"resource_version"
]
ret_json = [
resource
for resource in mock_json
if resource["resource_version"] == resource_version
]
return MockResponse(
{
"documents": ret_json,
},
200,
)
return MockResponse( return MockResponse(
{ {
"documents": mock_json, "documents": mock_json,
}, },
200, 200,
) )
if data["filter"]["id"] == "test-duplicate": if data["filter"]["$or"][0]["id"] == "test-duplicate":
return MockResponse( return MockResponse(
{ {
"documents": duplicate_mock_json, "documents": duplicate_mock_json,
}, },
200, 200,
) )
if data["filter"]["id"] == "test-too-many": if data["filter"]["$or"][0]["id"] == "test-too-many":
error_file = io.BytesIO() error_file = io.BytesIO()
error_file.status = 429 error_file.status = 429
raise HTTPError( raise HTTPError(
@@ -125,13 +140,15 @@ def mocked_requests_post(*args, **kwargs):
class ClientWrapperTestSuite(unittest.TestCase): class ClientWrapperTestSuite(unittest.TestCase):
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json),
) )
def test_get_resource_json_obj(self, mock_create_clients): def test_get_resource_json_obj(self, mock_create_clients):
mock_create_clients.side_effect = lambda x: _create_clients(
mock_config_json
)
# Test that the resource object is correctly returned # Test that the resource object is correctly returned
resource = "this-is-a-test-resource" resource = "this-is-a-test-resource"
resource = get_resource_json_obj(resource, gem5_version="develop") resource = get_resource_json_obj(resource, gem5_version="develop")
@@ -147,11 +164,15 @@ class ClientWrapperTestSuite(unittest.TestCase):
) )
self.assertEqual(resource["architecture"], "X86") self.assertEqual(resource["architecture"], "X86")
@patch("gem5.resources.client._create_clients") @patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch(
"gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json),
)
def test_get_resource_json_obj_invalid_client(self, mock_create_clients): def test_get_resource_json_obj_invalid_client(self, mock_create_clients):
mock_create_clients.side_effect = lambda x: _create_clients(
mock_config_json
)
# Test that an exception is raised when an invalid client is passed # Test that an exception is raised when an invalid client is passed
resource_id = "test-id" resource_id = "test-id"
client = "invalid" client = "invalid"
@@ -163,11 +184,15 @@ class ClientWrapperTestSuite(unittest.TestCase):
f"Client: {client} does not exist" in str(context.exception) f"Client: {client} does not exist" in str(context.exception)
) )
@patch("gem5.resources.client._create_clients") @patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch(
"gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json),
)
def test_get_resource_json_obj_with_version(self, mock_create_clients): def test_get_resource_json_obj_with_version(self, mock_create_clients):
mock_create_clients.side_effect = lambda x: _create_clients(
mock_config_json
)
# Test that the resource object is correctly returned # Test that the resource object is correctly returned
resource_id = "this-is-a-test-resource" resource_id = "this-is-a-test-resource"
resource_version = "1.0.0" resource_version = "1.0.0"
@@ -186,13 +211,16 @@ class ClientWrapperTestSuite(unittest.TestCase):
) )
self.assertEqual(resource["architecture"], "X86") self.assertEqual(resource["architecture"], "X86")
@patch("gem5.resources.client._create_clients") @patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch(
"gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_mongo),
)
@patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
def test_get_resource_json_obj_1(self, mock_get, mock_create_clients): def test_get_resource_json_obj_1(self, mock_get, mock_create_clients):
mock_create_clients.side_effect = lambda x: _create_clients(
mock_config_mongo
)
resource = "x86-ubuntu-18.04-img" resource = "x86-ubuntu-18.04-img"
resource = get_resource_json_obj(resource, gem5_version="develop") resource = get_resource_json_obj(resource, gem5_version="develop")
self.assertEqual(resource["id"], "x86-ubuntu-18.04-img") self.assertEqual(resource["id"], "x86-ubuntu-18.04-img")
@@ -209,253 +237,267 @@ class ClientWrapperTestSuite(unittest.TestCase):
) )
self.assertEqual(resource["architecture"], "X86") self.assertEqual(resource["architecture"], "X86")
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client.clientwrapper",
# ClientWrapper(mock_config_mongo), new=None,
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch(
# def test_get_resource_json_obj_with_version_mongodb(self, mock_get): "gem5.resources.client._create_clients",
# # Test that the resource object is correctly returned side_effect=lambda x: _create_clients(mock_config_mongo),
# resource_id = "x86-ubuntu-18.04-img" )
# resource_version = "1.0.0" @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# resource = get_resource_json_obj( def test_get_resource_json_obj_with_version_mongodb(
# resource_id, self, mock_get, mock_create_clients
# resource_version=resource_version, ):
# clients=["gem5-resources"], # Test that the resource object is correctly returned
# gem5_version="develop", resource_id = "x86-ubuntu-18.04-img"
# ) resource_version = "1.0.0"
# self.assertEqual(resource["id"], "x86-ubuntu-18.04-img") resource = get_resource_json_obj(
# self.assertEqual(resource["resource_version"], "1.0.0") resource_id,
# self.assertEqual(resource["category"], "disk-image") resource_version=resource_version,
# self.assertEqual(resource["description"], "This is a test resource") clients=["gem5-resources"],
# self.assertEqual( gem5_version="develop",
# resource["source_url"], )
# "https://github.com/gem5/gem5-resources/tree/develop/src/x86-ubuntu", self.assertEqual(resource["id"], "x86-ubuntu-18.04-img")
# ) self.assertEqual(resource["resource_version"], "1.0.0")
# self.assertEqual(resource["architecture"], "X86") self.assertEqual(resource["category"], "disk-image")
self.assertEqual(resource["description"], "This is a test resource")
self.assertEqual(
resource["source_url"],
"https://github.com/gem5/gem5-resources/tree/develop/src/x86-ubuntu",
)
self.assertEqual(resource["architecture"], "X86")
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_mongo), side_effect=lambda x: _create_clients(mock_config_mongo),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_json_obj_with_id_invalid_mongodb(self, mock_get): def test_get_resource_json_obj_with_id_invalid_mongodb(
# resource_id = "invalid-id" self, mock_get, mock_create_clients
# with self.assertRaises(Exception) as context: ):
# get_resource_json_obj( resource_id = "invalid-id"
# resource_id, clients=["gem5-resources"], gem5_version="develop" with self.assertRaises(Exception) as context:
# ) get_resource_json_obj(
# self.assertTrue( resource_id, clients=["gem5-resources"], gem5_version="develop"
# "Resource with ID 'invalid-id' not found." )
# in str(context.exception) self.assertTrue(
# ) "Resource with ID 'invalid-id' not found."
in str(context.exception)
)
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_mongo), side_effect=lambda x: _create_clients(mock_config_mongo),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_json_obj_with_version_invalid_mongodb( def test_get_resource_json_obj_with_version_invalid_mongodb(
# self, mock_get self, mock_get, mock_create_clients
# ): ):
# resource_id = "x86-ubuntu-18.04-img" resource_id = "x86-ubuntu-18.04-img"
# resource_version = "2.5.0" resource_version = "2.5.0"
# with self.assertRaises(Exception) as context: with self.assertRaises(Exception) as context:
# get_resource_json_obj( get_resource_json_obj(
# resource_id, resource_id,
# resource_version=resource_version, resource_version=resource_version,
# clients=["gem5-resources"], clients=["gem5-resources"],
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertTrue( print(str(context.exception))
# f"Resource x86-ubuntu-18.04-img with version '2.5.0'" self.assertTrue(
# " not found.\nResource versions can be found at: " "Resource with ID 'x86-ubuntu-18.04-img' not found."
# "https://resources.gem5.org/resources/x86-ubuntu-18.04-img/" in str(context.exception)
# "versions" in str(context.exception) )
# )
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client.clientwrapper",
# ClientWrapper(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
# ) )
# def test_get_resource_json_obj_with_version_invalid_json(self): def test_get_resource_json_obj_with_version_invalid_json(
# resource_id = "this-is-a-test-resource" self, mock_create_clients
# resource_version = "2.5.0" ):
# with self.assertRaises(Exception) as context: resource_id = "this-is-a-test-resource"
# get_resource_json_obj( resource_version = "2.5.0"
# resource_id, with self.assertRaises(Exception) as context:
# resource_version=resource_version, get_resource_json_obj(
# gem5_version="develop", resource_id,
# ) resource_version=resource_version,
# self.assertTrue( gem5_version="develop",
# "Resource this-is-a-test-resource with version '2.5.0'" )
# " not found.\nResource versions can be found at: " print(str(context.exception))
# "https://resources.gem5.org/resources/this-is-a-test-resource/" self.assertTrue(
# "versions" in str(context.exception) "source with ID 'this-is-a-test-resource' not found."
# ) in str(context.exception)
)
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_combined), side_effect=lambda x: _create_clients(mock_config_combined),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_json_obj_combine(self, mock_get): def test_get_resource_json_obj_combine(
# resource_id_mongo = "x86-ubuntu-18.04-img" self, mock_get, mock_create_clients
# resource_version_mongo = "1.0.0" ):
# resource_id_json = "this-is-a-test-resource" resource_id_mongo = "x86-ubuntu-18.04-img"
# resource_version_json = "1.0.0" resource_version_mongo = "1.0.0"
# resource_mongo = get_resource_json_obj( resource_id_json = "this-is-a-test-resource"
# resource_id_mongo, resource_version_json = "1.0.0"
# resource_version=resource_version_mongo, resource_mongo = get_resource_json_obj(
# clients=["gem5-resources"], resource_id_mongo,
# gem5_version="develop", resource_version=resource_version_mongo,
# ) clients=["gem5-resources"],
# resource_json = get_resource_json_obj( gem5_version="develop",
# resource_id_json, )
# resource_version=resource_version_json, resource_json = get_resource_json_obj(
# clients=["baba"], resource_id_json,
# gem5_version="develop", resource_version=resource_version_json,
# ) clients=["baba"],
# self.assertEqual(resource_mongo["id"], "x86-ubuntu-18.04-img") gem5_version="develop",
# self.assertEqual(resource_mongo["resource_version"], "1.0.0") )
# self.assertEqual(resource_mongo["category"], "disk-image") self.assertEqual(resource_mongo["id"], "x86-ubuntu-18.04-img")
# self.assertEqual( self.assertEqual(resource_mongo["resource_version"], "1.0.0")
# resource_mongo["description"], "This is a test resource" self.assertEqual(resource_mongo["category"], "disk-image")
# ) self.assertEqual(
# self.assertEqual( resource_mongo["description"], "This is a test resource"
# resource_mongo["source_url"], )
# "https://github.com/gem5/gem5-resources/tree/develop/src/" self.assertEqual(
# "x86-ubuntu", resource_mongo["source_url"],
# ) "https://github.com/gem5/gem5-resources/tree/develop/src/"
# self.assertEqual(resource_mongo["architecture"], "X86") "x86-ubuntu",
)
self.assertEqual(resource_mongo["architecture"], "X86")
# self.assertEqual(resource_json["id"], "this-is-a-test-resource") self.assertEqual(resource_json["id"], "this-is-a-test-resource")
# self.assertEqual(resource_json["resource_version"], "1.0.0") self.assertEqual(resource_json["resource_version"], "1.0.0")
# self.assertEqual(resource_json["category"], "binary") self.assertEqual(resource_json["category"], "binary")
# self.assertEqual( self.assertEqual(
# resource_json["description"], "This is a test resource" resource_json["description"], "This is a test resource"
# ) )
# self.assertEqual( self.assertEqual(
# resource_json["source_url"], resource_json["source_url"],
# "https://github.com/gem5/gem5-resources/tree/develop/src/asmtest", "https://github.com/gem5/gem5-resources/tree/develop/src/asmtest",
# ) )
# self.assertEqual(resource_json["architecture"], "X86") self.assertEqual(resource_json["architecture"], "X86")
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_combined), side_effect=lambda x: _create_clients(mock_config_combined),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_json_obj_multi_database_second_only(self, mock_get): def test_get_resource_json_obj_multi_database_second_only(
# resource_id = "simpoint-resource" self, mock_get, mock_create_clients
# resource = get_resource_json_obj( ):
# resource_id, resource_id = "simpoint-resource"
# gem5_version="develop", resource = get_resource_json_obj(
# ) resource_id,
# self.assertEqual(resource["id"], resource_id) gem5_version="DEVELOP",
# self.assertEqual(resource["resource_version"], "0.2.0") )
# self.assertEqual(resource["category"], "file") self.assertEqual(resource["id"], resource_id)
# self.assertEqual( self.assertEqual(resource["resource_version"], "0.2.0")
# resource["description"], self.assertEqual(resource["category"], "file")
# ( self.assertEqual(
# "Simpoints for running the 'x86-print-this' resource with" resource["description"],
# ' the parameters `"print this" 15000`. This is encapsulated' (
# " in the 'x86-print-this-15000-with-simpoints' workload." "Simpoints for running the 'x86-print-this' resource with"
# ), ' the parameters `"print this" 15000`. This is encapsulated'
# ) " in the 'x86-print-this-15000-with-simpoints' workload."
),
)
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_combined), side_effect=lambda x: _create_clients(mock_config_combined),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_json_same_resource_different_versions( def test_get_resource_json_same_resource_different_versions(
# self, mock_get self, mock_get, mock_create_clients
# ): ):
# resource_id = "x86-ubuntu-18.04-img" resource_id = "x86-ubuntu-18.04-img"
# resource_json = get_resource_json_obj( resource_json = get_resource_json_obj(
# resource_id, resource_id,
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img")
# self.assertEqual(resource_json["resource_version"], "2.0.0") self.assertEqual(resource_json["resource_version"], "2.0.0")
# self.assertEqual(resource_json["category"], "disk-image") self.assertEqual(resource_json["category"], "disk-image")
# resource_json = get_resource_json_obj( resource_json = get_resource_json_obj(
# resource_id, resource_version="1.0.0", gem5_version="develop" resource_id, resource_version="1.0.0", gem5_version="develop"
# ) )
# self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img") self.assertEqual(resource_json["id"], "x86-ubuntu-18.04-img")
# self.assertEqual(resource_json["resource_version"], "1.0.0") self.assertEqual(resource_json["resource_version"], "1.0.0")
# self.assertEqual(resource_json["category"], "disk-image") self.assertEqual(resource_json["category"], "disk-image")
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_combined), side_effect=lambda x: _create_clients(mock_config_combined),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_get_resource_same_resource_same_version(self, mock_get): def test_get_resource_same_resource_same_version(
# resource_id = "test-duplicate" self, mock_get, mock_create_clients
# with self.assertRaises(Exception) as context: ):
# get_resource_json_obj( resource_id = "test-duplicate"
# resource_id, with self.assertRaises(Exception) as context:
# gem5_version="develop", get_resource_json_obj(
# ) resource_id,
# self.assertTrue( gem5_version="develop",
# f"Resource {resource_id} has multiple resources with" )
# f" the same version: 0.2.0" in str(context.exception) self.assertTrue(
# ) f"Resource {resource_id} has multiple resources with"
f" the same version: 0.2.0" in str(context.exception)
)
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper( side_effect=lambda x: _create_clients(
# { {
# "sources": { "sources": {
# "gem5-resources": { "gem5-resources": {
# "dataSource": "gem5-vision", "dataSource": "gem5-vision",
# "database": "gem5-vision", "database": "gem5-vision",
# "collection": "versions_test", "collection": "versions_test",
# "url": "https://data.mongodb-api.com/app/data-ejhjf/endpoint/data/v1", "url": "https://data.mongodb-api.com/app/data-ejhjf/endpoint/data/v1",
# "authUrl": "https://realm.mongodb.com/api/client/v2.0/app/data-ejhjf/auth/providers/api-key/logi", "authUrl": "https://realm.mongodb.com/api/client/v2.0/app/data-ejhjf/auth/providers/api-key/logi",
# "apiKey": "OIi5bAP7xxIGK782t8ZoiD2BkBGEzMdX3upChf9zdCxHSnMoiTnjI22Yw5kOSgy9", "apiKey": "OIi5bAP7xxIGK782t8ZoiD2BkBGEzMdX3upChf9zdCxHSnMoiTnjI22Yw5kOSgy9",
# "isMongo": True, "isMongo": True,
# } }
# }, },
# } }
# ), ),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_invalid_auth_url(self, mock_get): def test_invalid_auth_url(self, mock_get, mock_create_clients):
# resource_id = "test-resource" resource_id = "test-resource"
# with self.assertRaises(AtlasClientHttpJsonRequestError) as context: with self.assertRaises(Exception) as context:
# get_resource_json_obj( get_resource_json_obj(
# resource_id, resource_id,
# gem5_version="develop", gem5_version="develop",
# ) )
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_mongo), side_effect=lambda x: _create_clients(mock_config_mongo),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_invalid_url(self, mock_get): def test_invalid_url(self, mock_get, mock_create_clients):
# resource_id = "test-resource" resource_id = "test-resource"
# with self.assertRaises(AtlasClientHttpJsonRequestError) as context: with self.assertRaises(AtlasClientHttpJsonRequestError) as context:
# get_resource_json_obj( get_resource_json_obj(
# resource_id, resource_id,
# gem5_version="develop", gem5_version="develop",
# ) )
# @patch( @patch(
# "gem5.resources.client.clientwrapper", "gem5.resources.client._create_clients",
# ClientWrapper(mock_config_mongo), side_effect=lambda x: _create_clients(mock_config_mongo),
# ) )
# @patch("urllib.request.urlopen", side_effect=mocked_requests_post) @patch("urllib.request.urlopen", side_effect=mocked_requests_post)
# def test_invalid_url(self, mock_get): def test_invalid_url(self, mock_get, mock_create_clients):
# resource_id = "test-too-many" resource_id = "test-too-many"
# with self.assertRaises(AtlasClientHttpJsonRequestError) as context: with self.assertRaises(AtlasClientHttpJsonRequestError) as context:
# get_resource_json_obj( get_resource_json_obj(
# resource_id, resource_id,
# gem5_version="develop", gem5_version="develop",
# ) )

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

@@ -52,6 +52,10 @@ mock_config_json = {
} }
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
@@ -71,58 +75,62 @@ class TestObtainResourcesCheck(unittest.TestCase):
"resources", "resources",
) )
# def test_obtain_resources_no_version(self, mock_create_client): def test_obtain_resources_no_version(self, mock_create_client):
# """Test that the resource loader returns latest version compatible with that version of gem5 when no version is specified.""" """Test that the resource loader returns latest version compatible with that version of gem5 when no version is specified."""
# gem5Version = core.gem5Version gem5Version = core.gem5Version
# resource = obtain_resource( resource = obtain_resource(
# resource_id="test-binary-resource", resource_id="test-binary-resource",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertEqual("1.7.0", resource.get_resource_version()) self.assertEqual("1.7.0", resource.get_resource_version())
# self.assertIsInstance(resource, BinaryResource) self.assertIsInstance(resource, BinaryResource)
# self.assertEqual("test description v1.7.0", resource.get_description()) self.assertEqual("test description v1.7.0", resource.get_description())
# self.assertEqual("src/test-source", resource.get_source()) self.assertEqual("src/test-source", resource.get_source())
# self.assertEqual(ISA.ARM, resource.get_architecture()) self.assertEqual(ISA.ARM, resource.get_architecture())
# def test_obtain_resources_with_version_compatible(self, mock_create_client): def test_obtain_resources_with_version_compatible(
# resource = obtain_resource( self, mock_create_client
# resource_id="test-binary-resource", ):
# resource_directory=self.get_resource_dir(), resource = obtain_resource(
# resource_version="1.5.0", resource_id="test-binary-resource",
# gem5_version="develop", resource_directory=self.get_resource_dir(),
# ) resource_version="1.5.0",
# self.assertEqual("1.5.0", resource.get_resource_version()) gem5_version="develop",
# self.assertIsInstance(resource, BinaryResource) )
# self.assertEqual( self.assertEqual("1.5.0", resource.get_resource_version())
# "test description for 1.5.0", resource.get_description() self.assertIsInstance(resource, BinaryResource)
# ) self.assertEqual(
# self.assertEqual("src/test-source", resource.get_source()) "test description for 1.5.0", resource.get_description()
# self.assertEqual(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, mock_create_client): def test_obtain_resources_with_version_incompatible(
# resource = None self, mock_create_client
# f = io.StringIO() ):
# with contextlib.redirect_stderr(f): resource = None
# resource = obtain_resource( f = io.StringIO()
# resource_id="test-binary-resource", with contextlib.redirect_stderr(f):
# resource_directory=self.get_resource_dir(), resource = obtain_resource(
# resource_version="1.5.0", resource_id="test-binary-resource",
# ) resource_directory=self.get_resource_dir(),
resource_version="1.5.0",
)
# resource = obtain_resource( resource = obtain_resource(
# resource_id="test-binary-resource", resource_id="test-binary-resource",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# resource_version="1.5.0", resource_version="1.5.0",
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertEqual("1.5.0", resource.get_resource_version()) self.assertEqual("1.5.0", resource.get_resource_version())
# self.assertIsInstance(resource, BinaryResource) self.assertIsInstance(resource, BinaryResource)
# self.assertEqual( self.assertEqual(
# "test description for 1.5.0", resource.get_description() "test description for 1.5.0", resource.get_description()
# ) )
# self.assertEqual("src/test-source", resource.get_source()) self.assertEqual("src/test-source", resource.get_source())
# self.assertEqual(ISA.ARM, resource.get_architecture()) self.assertEqual(ISA.ARM, resource.get_architecture())
def test_obtain_resources_no_version_invalid_id(self, mock_create_client): def test_obtain_resources_no_version_invalid_id(self, mock_create_client):
with self.assertRaises(Exception) as context: with self.assertRaises(Exception) as context:

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

@@ -52,6 +52,10 @@ mock_config_json = {
} }
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
@@ -76,219 +80,221 @@ class ResourceSpecializationSuite(unittest.TestCase):
"resources", "resources",
) )
# def test_binary_resource(self, mock_create_clients) -> None: def test_binary_resource(self, mock_create_clients) -> None:
# """Tests the loading of of a BinaryResource""" """Tests the loading of of a BinaryResource"""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="binary-example", resource_id="binary-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, BinaryResource) self.assertIsInstance(resource, BinaryResource)
# self.assertEqual( self.assertEqual(
# "binary-example documentation.", resource.get_description() "binary-example documentation.", resource.get_description()
# ) )
# self.assertEqual("src/simple", resource.get_source()) self.assertEqual("src/simple", resource.get_source())
# self.assertEqual(ISA.ARM, resource.get_architecture()) self.assertEqual(ISA.ARM, resource.get_architecture())
# def test_kernel_resource(self, mock_create_clients) -> None: def test_kernel_resource(self, mock_create_clients) -> None:
# """Tests the loading of a KernelResource.""" """Tests the loading of a KernelResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="kernel-example", resource_id="kernel-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, KernelResource) self.assertIsInstance(resource, KernelResource)
# self.assertEqual( self.assertEqual(
# "kernel-example documentation.", resource.get_description() "kernel-example documentation.", resource.get_description()
# ) )
# self.assertEqual("src/linux-kernel", resource.get_source()) self.assertEqual("src/linux-kernel", resource.get_source())
# self.assertEqual(ISA.RISCV, resource.get_architecture()) self.assertEqual(ISA.RISCV, resource.get_architecture())
# def test_bootloader_resource(self, mock_create_clients) -> None: def test_bootloader_resource(self, mock_create_clients) -> None:
# """Tests the loading of a BootloaderResource.""" """Tests the loading of a BootloaderResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="bootloader-example", resource_id="bootloader-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, BootloaderResource) self.assertIsInstance(resource, BootloaderResource)
# self.assertEqual( self.assertEqual(
# "bootloader documentation.", resource.get_description() "bootloader documentation.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# self.assertIsNone(resource.get_architecture()) self.assertIsNone(resource.get_architecture())
# def test_disk_image_resource(self, mock_create_clients) -> None: def test_disk_image_resource(self, mock_create_clients) -> None:
# """Tests the loading of a DiskImageResource.""" """Tests the loading of a DiskImageResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="disk-image-example", resource_id="disk-image-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, DiskImageResource) self.assertIsInstance(resource, DiskImageResource)
# self.assertEqual( self.assertEqual(
# "disk-image documentation.", resource.get_description() "disk-image documentation.", resource.get_description()
# ) )
# self.assertEqual("src/x86-ubuntu", resource.get_source()) self.assertEqual("src/x86-ubuntu", resource.get_source())
# self.assertEqual("1", resource.get_root_partition()) self.assertEqual("1", resource.get_root_partition())
# def test_checkpoint_resource(self, mock_create_clients) -> None: def test_checkpoint_resource(self, mock_create_clients) -> None:
# """Tests the loading of a CheckpointResource.""" """Tests the loading of a CheckpointResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="checkpoint-example", resource_id="checkpoint-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, CheckpointResource) self.assertIsInstance(resource, CheckpointResource)
# self.assertEqual( self.assertEqual(
# "checkpoint-example documentation.", resource.get_description() "checkpoint-example documentation.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# def test_git_resource(self, mock_create_clients) -> None: def test_git_resource(self, mock_create_clients) -> None:
# """Tests the loading of a GitResource.""" """Tests the loading of a GitResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="git-example", resource_id="git-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, GitResource) self.assertIsInstance(resource, GitResource)
# self.assertIsNone(resource.get_description()) self.assertIsNone(resource.get_description())
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# def test_simpoint_directory_resource(self, mock_create_clients) -> None: def test_simpoint_directory_resource(self, mock_create_clients) -> None:
# """Tests the loading of a Simpoint directory resource.""" """Tests the loading of a Simpoint directory resource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="simpoint-directory-example", resource_id="simpoint-directory-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, SimpointDirectoryResource) self.assertIsInstance(resource, SimpointDirectoryResource)
# self.assertEqual( self.assertEqual(
# "simpoint directory documentation.", resource.get_description() "simpoint directory documentation.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# self.assertEqual(1000000, resource.get_simpoint_interval()) self.assertEqual(1000000, resource.get_simpoint_interval())
# self.assertEqual(1000000, resource.get_warmup_interval()) self.assertEqual(1000000, resource.get_warmup_interval())
# self.assertEqual( self.assertEqual(
# Path( Path(
# Path(self.get_resource_dir()) Path(self.get_resource_dir())
# / "simpoint-directory-example" / "simpoint-directory-example"
# / "simpoint.simpt" / "simpoint.simpt"
# ), ),
# resource.get_simpoint_file(), resource.get_simpoint_file(),
# ) )
# self.assertEqual( self.assertEqual(
# Path( Path(
# Path(self.get_resource_dir()) Path(self.get_resource_dir())
# / "simpoint-directory-example" / "simpoint-directory-example"
# / "simpoint.weight" / "simpoint.weight"
# ), ),
# resource.get_weight_file(), resource.get_weight_file(),
# ) )
# self.assertEqual("Example Workload", resource.get_workload_name()) self.assertEqual("Example Workload", resource.get_workload_name())
# def test_simpoint_resource(self, mock_create_clients) -> None: def test_simpoint_resource(self, mock_create_clients) -> None:
# """Tests the loading of a Simpoint resource.""" """Tests the loading of a Simpoint resource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="simpoint-example", resource_id="simpoint-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, SimpointResource) self.assertIsInstance(resource, SimpointResource)
# self.assertEqual("simpoint documentation.", resource.get_description()) self.assertEqual("simpoint documentation.", resource.get_description())
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# self.assertIsNone(resource.get_local_path()) self.assertIsNone(resource.get_local_path())
# self.assertEqual(1000000, resource.get_simpoint_interval()) self.assertEqual(1000000, resource.get_simpoint_interval())
# self.assertEqual(23445, resource.get_warmup_interval()) self.assertEqual(23445, resource.get_warmup_interval())
# self.assertEqual([2, 3, 4, 15], resource.get_simpoint_list()) self.assertEqual([2, 3, 4, 15], resource.get_simpoint_list())
# self.assertEqual([0.1, 0.2, 0.4, 0.3], resource.get_weight_list()) self.assertEqual([0.1, 0.2, 0.4, 0.3], resource.get_weight_list())
# def test_file_resource(self, mock_create_clients) -> None: def test_file_resource(self, mock_create_clients) -> None:
# """Tests the loading of a FileResource.""" """Tests the loading of a FileResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="file-example", resource_id="file-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# resource_version="1.0.0", resource_version="1.0.0",
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, FileResource) self.assertIsInstance(resource, FileResource)
# self.assertIsNone(resource.get_description()) self.assertIsNone(resource.get_description())
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# def test_directory_resource(self, mock_create_clients) -> None: def test_directory_resource(self, mock_create_clients) -> None:
# """Tests the loading of a DirectoryResource.""" """Tests the loading of a DirectoryResource."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="directory-example", resource_id="directory-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# ) )
# self.assertIsInstance(resource, DirectoryResource) self.assertIsInstance(resource, DirectoryResource)
# self.assertEqual( self.assertEqual(
# "directory-example documentation.", resource.get_description() "directory-example documentation.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# def test_looppoint_pinpoints_resource(self, mock_create_clients) -> None: def test_looppoint_pinpoints_resource(self, mock_create_clients) -> None:
# """Tests the creation of LooppointCreatorCSVResource via a Looppoint """Tests the creation of LooppointCreatorCSVResource via a Looppoint
# pinpoints csv file.""" pinpoints csv file."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="looppoint-pinpoint-csv-resource", resource_id="looppoint-pinpoint-csv-resource",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, LooppointCsvResource) self.assertIsInstance(resource, LooppointCsvResource)
# # The LooppointCreatorCSVResource should be a subtype of # The LooppointCreatorCSVResource should be a subtype of
# # LooppointCsvLoader. # LooppointCsvLoader.
# self.assertIsInstance(resource, LooppointCsvLoader) self.assertIsInstance(resource, LooppointCsvLoader)
# self.assertEqual( self.assertEqual(
# "A looppoint pinpoints csv file.", resource.get_description() "A looppoint pinpoints csv file.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())
# def test_looppoint_json_restore_resource(self, mock_create_clients) -> None: def test_looppoint_json_restore_resource(
# """Tests the creation of LooppointJsonResource via a self, mock_create_clients
# Looppoint JSON file.""" ) -> None:
"""Tests the creation of LooppointJsonResource via a
Looppoint JSON file."""
# resource = obtain_resource( resource = obtain_resource(
# resource_id="looppoint-json-restore-resource-region-1-example", resource_id="looppoint-json-restore-resource-region-1-example",
# resource_directory=self.get_resource_dir(), resource_directory=self.get_resource_dir(),
# resource_version="1.0.0", resource_version="1.0.0",
# gem5_version="develop", gem5_version="develop",
# ) )
# self.assertIsInstance(resource, LooppointJsonResource) self.assertIsInstance(resource, LooppointJsonResource)
# self.assertIsInstance(resource, LooppointJsonLoader) self.assertIsInstance(resource, LooppointJsonLoader)
# self.assertEqual(1, len(resource.get_regions())) self.assertEqual(1, len(resource.get_regions()))
# self.assertTrue("1" in resource.get_regions()) self.assertTrue("1" in resource.get_regions())
# self.assertEqual( self.assertEqual(
# "A looppoint json file resource.", resource.get_description() "A looppoint json file resource.", resource.get_description()
# ) )
# self.assertIsNone(resource.get_source()) self.assertIsNone(resource.get_source())

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

@@ -52,6 +52,10 @@ mock_config_json = {
class CustomSuiteResourceTestSuite(unittest.TestCase): class CustomSuiteResourceTestSuite(unittest.TestCase):
@classmethod @classmethod
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
@@ -63,110 +67,137 @@ class CustomSuiteResourceTestSuite(unittest.TestCase):
workloads={cls.workload1: set(), cls.workload2: set()} workloads={cls.workload1: set(), cls.workload2: set()}
) )
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch(
"gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json),
)
def test_with_input_group(self, mock_create_clients) -> None:
"""
Tests the `with_input_group` function.
"""
# test if an input group can return a single workload in a suite resource
# @patch( with self.assertRaises(Exception) as context:
# "gem5.resources.client._create_clients", filtered_suite = self.SuiteResource.with_input_group("testtag2")
# side_effect=lambda x: _create_clients(mock_config_json), self.assertIsInstance(filtered_suite, SuiteResource)
# ) self.assertEqual(len(filtered_suite), 0)
# def test_with_input_group(self, mock_create_clients) -> None: self.assertTrue(
# """ f"Input group invalid not found in Suite.\n"
# Tests the `with_input_group` function. f"Available input groups are {filtered_suite.get_input_groups()}"
# """ in str(context.exception)
# # test if an input group can return a single workload in a suite resource )
# with self.assertRaises(Exception) as context: def test_get_input_groups(self):
# filtered_suite = self.SuiteResource.with_input_group("testtag2") """
# self.assertIsInstance(filtered_suite, SuiteResource) Tests the `list_input_groups` function.
# self.assertEqual(len(filtered_suite), 0) """
# self.assertTrue( self.assertEqual(self.SuiteResource.get_input_groups(), set())
# f"Input group invalid not found in Suite.\n"
# f"Available input groups are {filtered_suite.get_input_groups()}"
# in str(context.exception)
# )
# def test_get_input_groups(self):
# """
# Tests the `list_input_groups` function.
# """
# self.assertEqual(self.SuiteResource.get_input_groups(), set())
# class SuiteResourceTestSuite(unittest.TestCase): class SuiteResourceTestSuite(unittest.TestCase):
# @classmethod @classmethod
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def setUpClass(cls, mock_create_clients): @patch(
# cls.suite = obtain_resource("suite-example", gem5_version="develop") "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json),
)
def setUpClass(cls, mock_create_clients):
cls.suite = obtain_resource("suite-example", gem5_version="develop")
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def test_with_input_group(self, mock_create_clients) -> None: @patch(
# """ "gem5.resources.client._create_clients",
# Tests the `with_input_group` function. side_effect=lambda x: _create_clients(mock_config_json),
# """ )
# # test if an input group can return a single workload in a suite resource def test_with_input_group(self, mock_create_clients) -> None:
# filtered_suite = self.suite.with_input_group("testtag2") """
# self.assertIsInstance(filtered_suite, SuiteResource) Tests the `with_input_group` function.
# self.assertEqual(len(filtered_suite), 1) """
# for workload in filtered_suite: # test if an input group can return a single workload in a suite resource
# self.assertIsInstance(workload, WorkloadResource) filtered_suite = self.suite.with_input_group("testtag2")
self.assertIsInstance(filtered_suite, SuiteResource)
self.assertEqual(len(filtered_suite), 1)
for workload in filtered_suite:
self.assertIsInstance(workload, WorkloadResource)
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def test_with_input_group_multiple(self, mock_create_clients) -> None: @patch(
# # test if an input group can return multiple workloads in a suite resource "gem5.resources.client._create_clients",
# filtered_suite = self.suite.with_input_group("testtag1") side_effect=lambda x: _create_clients(mock_config_json),
# self.assertIsInstance(filtered_suite, SuiteResource) )
# self.assertEqual(len(filtered_suite), 2) def test_with_input_group_multiple(self, mock_create_clients) -> None:
# for workload in filtered_suite: # test if an input group can return multiple workloads in a suite resource
# self.assertIsInstance(workload, WorkloadResource) filtered_suite = self.suite.with_input_group("testtag1")
self.assertIsInstance(filtered_suite, SuiteResource)
self.assertEqual(len(filtered_suite), 2)
for workload in filtered_suite:
self.assertIsInstance(workload, WorkloadResource)
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def test_with_input_group_invalid(self, mock_create_clients) -> None: @patch(
# """ "gem5.resources.client._create_clients",
# Tests the `with_input_group` function with an invalid input group. side_effect=lambda x: _create_clients(mock_config_json),
# """ )
# with self.assertRaises(Exception) as context: def test_with_input_group_invalid(self, mock_create_clients) -> None:
# filtered_suite = self.suite.with_input_group("invalid") """
# # check if exception is raised Tests the `with_input_group` function with an invalid input group.
# self.assertTrue( """
# f"Input group invalid not found in Suite.\n" with self.assertRaises(Exception) as context:
# f"Available input groups are {filtered_suite.get_input_groups()}" filtered_suite = self.suite.with_input_group("invalid")
# in str(context.exception) # check if exception is raised
# ) self.assertTrue(
f"Input group invalid not found in Suite.\n"
f"Available input groups are {filtered_suite.get_input_groups()}"
in str(context.exception)
)
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def test_get_input_groups(self, mock_create_clients) -> None: @patch(
# """ "gem5.resources.client._create_clients",
# Tests the `list_input_groups` function. side_effect=lambda x: _create_clients(mock_config_json),
# """ )
# expected_input_groups = {"testtag1", "testtag2", "testtag3"} def test_get_input_groups(self, mock_create_clients) -> None:
# self.assertEqual(self.suite.get_input_groups(), expected_input_groups) """
Tests the `list_input_groups` function.
"""
expected_input_groups = {"testtag1", "testtag2", "testtag3"}
self.assertEqual(self.suite.get_input_groups(), expected_input_groups)
# @patch( @patch(
# "gem5.resources.client._create_clients", "gem5.resources.client.clientwrapper",
# side_effect=lambda x: _create_clients(mock_config_json), new=None,
# ) )
# def test_get_input_groups_not_found(self, mock_create_clients) -> None: @patch(
# """ "gem5.resources.client._create_clients",
# Tests the `list_input_groups` function with an invalid input group. side_effect=lambda x: _create_clients(mock_config_json),
# """ )
# with self.assertRaises(Exception) as context: def test_get_input_groups_not_found(self, mock_create_clients) -> None:
# self.suite.get_input_groups("invalid") """
# self.assertTrue( Tests the `list_input_groups` function with an invalid input group.
# f"Input group invalid not found in Suite.\n" """
# f"Available input groups are {self.suite.get_input_groups()}" with self.assertRaises(Exception) as context:
# in str(context.exception) self.suite.get_input_groups("invalid")
# ) self.assertTrue(
f"Input group invalid not found in Suite.\n"
f"Available input groups are {self.suite.get_input_groups()}"
in str(context.exception)
)

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

@@ -30,7 +30,10 @@ from pathlib import Path
from typing import Dict from typing import Dict
from unittest.mock import patch from unittest.mock import patch
from gem5.resources.client import _create_clients from gem5.resources.client import (
_create_clients,
clientwrapper,
)
from gem5.resources.resource import ( from gem5.resources.resource import (
BinaryResource, BinaryResource,
DiskImageResource, DiskImageResource,
@@ -58,6 +61,10 @@ class CustomWorkloadTestSuite(unittest.TestCase):
""" """
@classmethod @classmethod
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
@@ -73,57 +80,57 @@ class CustomWorkloadTestSuite(unittest.TestCase):
}, },
) )
# def test_get_function_str(self) -> None: def test_get_function_str(self) -> None:
# # Tests `CustomWorkload.get_function_str` # Tests `CustomWorkload.get_function_str`
# self.assertEqual( self.assertEqual(
# "set_se_binary_workload", self.custom_workload.get_function_str() "set_se_binary_workload", self.custom_workload.get_function_str()
# ) )
# def test_get_parameters(self) -> None: def test_get_parameters(self) -> None:
# # Tests `CustomWorkload.get_parameter` # Tests `CustomWorkload.get_parameter`
# parameters = self.custom_workload.get_parameters() parameters = self.custom_workload.get_parameters()
# self.assertTrue(isinstance(parameters, Dict)) self.assertTrue(isinstance(parameters, Dict))
# self.assertEqual(2, len(parameters)) self.assertEqual(2, len(parameters))
# self.assertTrue("binary" in parameters) self.assertTrue("binary" in parameters)
# self.assertTrue(isinstance(parameters["binary"], BinaryResource)) self.assertTrue(isinstance(parameters["binary"], BinaryResource))
# self.assertTrue("arguments" in parameters) self.assertTrue("arguments" in parameters)
# self.assertTrue(isinstance(parameters["arguments"], list)) self.assertTrue(isinstance(parameters["arguments"], list))
# self.assertEqual(2, len(parameters["arguments"])) self.assertEqual(2, len(parameters["arguments"]))
# self.assertEqual("hello", parameters["arguments"][0]) self.assertEqual("hello", parameters["arguments"][0])
# self.assertEqual(6, parameters["arguments"][1]) self.assertEqual(6, parameters["arguments"][1])
# def test_add_parameters(self) -> None: def test_add_parameters(self) -> None:
# # Tests `CustomWorkload.set_parameter` for the case where we add a new # Tests `CustomWorkload.set_parameter` for the case where we add a new
# # parameter value. # parameter value.
# self.custom_workload.set_parameter("test_param", 10) self.custom_workload.set_parameter("test_param", 10)
# self.assertTrue("test_param" in self.custom_workload.get_parameters()) self.assertTrue("test_param" in self.custom_workload.get_parameters())
# self.assertEqual( self.assertEqual(
# 10, self.custom_workload.get_parameters()["test_param"] 10, self.custom_workload.get_parameters()["test_param"]
# ) )
# # Cleanup # Cleanup
# del self.custom_workload.get_parameters()["test_param"] del self.custom_workload.get_parameters()["test_param"]
# def test_override_parameter(self) -> None: def test_override_parameter(self) -> None:
# # Tests `CustomWorkload.set_parameter` for the case where we override # Tests `CustomWorkload.set_parameter` for the case where we override
# # a parameter's value. # a parameter's value.
# old_value = self.custom_workload.get_parameters()["binary"] old_value = self.custom_workload.get_parameters()["binary"]
# self.custom_workload.set_parameter("binary", "test") self.custom_workload.set_parameter("binary", "test")
# self.assertTrue("binary" in self.custom_workload.get_parameters()) self.assertTrue("binary" in self.custom_workload.get_parameters())
# self.assertEqual( self.assertEqual(
# "test", self.custom_workload.get_parameters()["binary"] "test", self.custom_workload.get_parameters()["binary"]
# ) )
# # We set the overridden parameter back to it's old value # We set the overridden parameter back to it's old value
# self.custom_workload.set_parameter("binary", old_value) self.custom_workload.set_parameter("binary", old_value)
class WorkloadTestSuite(unittest.TestCase): class WorkloadTestSuite(unittest.TestCase):
@@ -132,6 +139,10 @@ class WorkloadTestSuite(unittest.TestCase):
""" """
@classmethod @classmethod
@patch(
"gem5.resources.client.clientwrapper",
new=None,
)
@patch( @patch(
"gem5.resources.client._create_clients", "gem5.resources.client._create_clients",
side_effect=lambda x: _create_clients(mock_config_json), side_effect=lambda x: _create_clients(mock_config_json),
@@ -139,57 +150,57 @@ class WorkloadTestSuite(unittest.TestCase):
def setUpClass(cls, mock_create_client): def setUpClass(cls, mock_create_client):
cls.workload = obtain_resource("simple-boot", gem5_version="develop") cls.workload = obtain_resource("simple-boot", gem5_version="develop")
# def test_get_function_str(self) -> None: def test_get_function_str(self) -> None:
# # Tests `Resource.get_function_str` # Tests `Resource.get_function_str`
# self.assertEqual( self.assertEqual(
# "set_kernel_disk_workload", self.workload.get_function_str() "set_kernel_disk_workload", self.workload.get_function_str()
# ) )
# def test_get_parameters(self) -> None: def test_get_parameters(self) -> None:
# # Tests `Resource.get_parameters` # Tests `Resource.get_parameters`
# parameters = self.workload.get_parameters() parameters = self.workload.get_parameters()
# self.assertTrue(isinstance(parameters, Dict)) self.assertTrue(isinstance(parameters, Dict))
# self.assertEqual(3, len(parameters)) self.assertEqual(3, len(parameters))
# self.assertTrue("kernel" in parameters) self.assertTrue("kernel" in parameters)
# self.assertTrue(isinstance(parameters["kernel"], BinaryResource)) self.assertTrue(isinstance(parameters["kernel"], BinaryResource))
# self.assertTrue("disk-image" in parameters) self.assertTrue("disk-image" in parameters)
# self.assertTrue( self.assertTrue(
# isinstance(parameters["disk-image"], DiskImageResource) isinstance(parameters["disk-image"], DiskImageResource)
# ) )
# self.assertTrue("readfile_contents" in parameters) self.assertTrue("readfile_contents" in parameters)
# self.assertTrue( self.assertTrue(
# "echo 'Boot successful'; m5 exit", parameters["readfile_contents"] "echo 'Boot successful'; m5 exit", parameters["readfile_contents"]
# ) )
# def test_add_parameters(self) -> None: def test_add_parameters(self) -> None:
# # Tests `Resource.set_parameter` for the case where we add a new # Tests `Resource.set_parameter` for the case where we add a new
# # parameter value. # parameter value.
# self.workload.set_parameter("test_param", 10) self.workload.set_parameter("test_param", 10)
# self.assertTrue("test_param" in self.workload.get_parameters()) self.assertTrue("test_param" in self.workload.get_parameters())
# self.assertEqual(10, self.workload.get_parameters()["test_param"]) self.assertEqual(10, self.workload.get_parameters()["test_param"])
# # Cleanup # Cleanup
# del self.workload.get_parameters()["test_param"] del self.workload.get_parameters()["test_param"]
# def test_override_parameter(self) -> None: def test_override_parameter(self) -> None:
# # Tests `Resource.set_parameter` for the case where we override # Tests `Resource.set_parameter` for the case where we override
# # a parameter's value. # a parameter's value.
# old_value = self.workload.get_parameters()["readfile_contents"] old_value = self.workload.get_parameters()["readfile_contents"]
# self.workload.set_parameter("readfile_contents", "test") self.workload.set_parameter("readfile_contents", "test")
# self.assertTrue("readfile_contents" in self.workload.get_parameters()) self.assertTrue("readfile_contents" in self.workload.get_parameters())
# self.assertEqual( self.assertEqual(
# "test", self.workload.get_parameters()["readfile_contents"] "test", self.workload.get_parameters()["readfile_contents"]
# ) )
# # We set the overridden parameter back to it's old value. # We set the overridden parameter back to it's old value.
# self.workload.set_parameter("readfile_contents", old_value) self.workload.set_parameter("readfile_contents", old_value)