test_*.
3. Based on the requirement one can inherit TestNVMe or TestNVMeIO
class.
- 4. Write test precondition code into __init__. Make sure you are calling
- super class __init__.
- 5. Write test post condition code into __del__. Make sure you are calling
- super class __del__.
+ 4. Write test precondition code into setUp. Make sure you are calling
+ super class setUp.
+ 5. Write test post condition code into tearDown. Make sure you are calling
+ super class tearDown.
6. Before writing a new function have a look into TestNVMe to see if it
can be reused.
7. Once testcase is ready make sure :-
4. Running testcases with framework
-----------------------------------
- 1. Running single testcase with nose2 :-
- $ nose2 --verbose nvme_writezeros_test
- $ nose2 --verbose nvme_read_write_test
+ 1. Running single testcase (in the source tree) with nose2 :-
+ $ nose2 --verbose --start-dir tests nvme_writezeros_test
+ $ nose2 --verbose --start-dir tests nvme_read_write_test
- 2. Running all the testcases with ninja :-
+ 2. Running all the testcases (in the build root directory) with ninja :-
$ ninja test -C .build
# SPDX-License-Identifier: GPL-2.0-or-later
+infra = [
+ 'config.json',
+ 'nvme_test.py',
+ 'nvme_test_io.py',
+ 'nvme_test_logger.py',
+ 'nvme_simple_template_test.py',
+]
+
tests = [
- 'nvme_attach_detach_ns_test',
- 'nvme_compare_test',
- 'nvme_create_max_ns_test',
- 'nvme_error_log_test',
- 'nvme_flush_test',
- 'nvme_format_test',
- 'nvme_fw_log_test',
- 'nvme_get_features_test',
- 'nvme_id_ctrl_test',
- 'nvme_id_ns_test',
- 'nvme_read_write_test',
- 'nvme_simple_template_test',
- 'nvme_smart_log_test',
- 'nvme_test_io',
- 'nvme_test_logger',
- 'nvme_test',
- 'nvme_writeuncor_test',
- 'nvme_writezeros_test',
- 'nvme_copy_test',
- 'nvme_dsm_test',
- 'nvme_verify_test',
- 'nvme_lba_status_log_test',
- 'nvme_get_lba_status_test',
+ 'nvme_attach_detach_ns_test.py',
+ 'nvme_compare_test.py',
+ 'nvme_create_max_ns_test.py',
+ 'nvme_error_log_test.py',
+ 'nvme_flush_test.py',
+ 'nvme_format_test.py',
+ 'nvme_fw_log_test.py',
+ 'nvme_get_features_test.py',
+ 'nvme_id_ctrl_test.py',
+ 'nvme_id_ns_test.py',
+ 'nvme_read_write_test.py',
+ 'nvme_smart_log_test.py',
+ 'nvme_writeuncor_test.py',
+ 'nvme_writezeros_test.py',
+ 'nvme_copy_test.py',
+ 'nvme_dsm_test.py',
+ 'nvme_verify_test.py',
+ 'nvme_lba_status_log_test.py',
+ 'nvme_get_lba_status_test.py',
]
runtests = find_program('nose2', required : false)
if runtests.found()
+ foreach file : infra + tests
+ configure_file(
+ input: file,
+ output: file,
+ copy: true)
+ endforeach
+
foreach t : tests
- test(t, runtests,
- args: ['--verbose', '--start-dir', meson.current_source_dir(), t],
- workdir: meson.current_source_dir(),
+ t_name = t.split('.')[0]
+ test(t_name, runtests,
+ args: ['--verbose', '--start-dir', meson.build_root() + '/tests', t_name],
env: ['PATH=' + meson.build_root() + ':/usr/bin:/usr/sbin'],
timeout: 500)
endforeach
import time
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- ctrl_id : controller id.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeAttachDetachNSCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.dps = 0
self.flbas = 0
self.nsze = 0x1400000
self.delete_all_ns()
time.sleep(1)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeAttachDetachNSCmd
- Atttach it to controller.
- Call super class's destructor.
"""
- assert_equal(self.create_and_validate_ns(self.default_nsid,
- self.nsze,
- self.ncap,
- self.flbas,
- self.dps), 0)
+ self.assertEqual(self.create_and_validate_ns(self.default_nsid,
+ self.nsze,
+ self.ncap,
+ self.flbas,
+ self.dps), 0)
self.attach_ns(self.ctrl_id, self.default_nsid)
- TestNVMe.__del__(self)
+ super().tearDown()
def test_attach_detach_ns(self):
""" Testcase main """
self.ncap,
self.flbas,
self.dps)
- assert_equal(err, 0)
- assert_equal(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(err, 0)
+ self.assertEqual(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
self.run_ns_io(self.default_nsid, 0)
- assert_equal(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
- assert_equal(self.delete_and_validate_ns(self.default_nsid), 0)
+ self.assertEqual(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(self.delete_and_validate_ns(self.default_nsid), 0)
self.nvme_reset_ctrl()
"""
-from nose.tools import assert_equal, assert_not_equal
from nvme_test_io import TestNVMeIO
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeCompareCmd """
- TestNVMeIO.__init__(self)
+ super().setUp()
self.data_size = 1024
self.start_block = 1023
self.setup_log_dir(self.__class__.__name__)
self.create_data_file(self.write_file, self.data_size, "15")
self.create_data_file(self.compare_file, self.data_size, "25")
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeCompareCmd """
- TestNVMeIO.__del__(self)
+ super().tearDown()
def nvme_compare(self, cmp_file):
""" Wrapper for nvme compare command.
def test_nvme_compare(self):
""" Testcase main """
- assert_equal(self.nvme_write(), 0)
- assert_not_equal(self.nvme_compare(self.compare_file), 0)
- assert_equal(self.nvme_compare(self.write_file), 0)
+ self.assertEqual(self.nvme_write(), 0)
+ self.assertNotEqual(self.nvme_compare(self.compare_file), 0)
+ self.assertEqual(self.nvme_compare(self.write_file), 0)
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeCopy """
- TestNVMe.__init__(self)
+ super().setUp()
self.start_block = 0
self.range = 1
self.slbs = 1
self.namespace = 1
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeCopy """
- TestNVMe.__del__(self)
+ super().tearDown()
def copy(self):
""" Wrapper for nvme copy
def test_copy(self):
""" Testcase main """
- assert_equal(self.copy(), 0)
+ self.assertEqual(self.copy(), 0)
import time
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- ctrl_id : controller id.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeAttachDetachNSCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.dps = 0
self.flbas = 0
self.nsze = int(self.get_ncap() /
self.delete_all_ns()
time.sleep(1)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeAttachDetachNSCmd
- Atttach it to controller.
- Call super class's destructor.
"""
- assert_equal(self.create_and_validate_ns(self.default_nsid,
- self.nsze,
- self.ncap,
- self.flbas,
- self.dps), 0)
+ self.assertEqual(self.create_and_validate_ns(self.default_nsid,
+ self.nsze,
+ self.ncap,
+ self.flbas,
+ self.dps), 0)
self.attach_ns(self.ctrl_id, self.default_nsid)
- TestNVMe.__del__(self)
+ super.tearDown()
def test_attach_detach_ns(self):
""" Testcase main """
self.ncap,
self.flbas,
self.dps)
- assert_equal(err, 0)
+ self.assertEqual(err, 0)
print("##### Attaching " + str(nsid))
- assert_equal(self.attach_ns(self.ctrl_id, nsid), 0)
+ self.assertEqual(self.attach_ns(self.ctrl_id, nsid), 0)
print("##### Running IOs in " + str(nsid))
self.run_ns_io(nsid, 0)
for nsid in range(1, self.max_ns):
print("##### Detaching " + str(nsid))
- assert_equal(self.detach_ns(self.ctrl_id, nsid), 0)
+ self.assertEqual(self.detach_ns(self.ctrl_id, nsid), 0)
print("#### Deleting " + str(nsid))
- assert_equal(self.delete_and_validate_ns(nsid), 0)
+ self.assertEqual(self.delete_and_validate_ns(nsid), 0)
self.nvme_reset_ctrl()
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeDsm """
- TestNVMe.__init__(self)
+ super().setUp()
self.start_block = 0
self.range = 0
self.namespace = 1
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeDsm """
- TestNVMe.__del__(self)
+ super().tearDown()
def dsm(self):
""" Wrapper for nvme verify
def test_dsm(self):
""" Testcase main """
- assert_equal(self.dsm(), 0)
+ self.assertEqual(self.dsm(), 0)
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- Attributes:
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeErrorLogCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeErrorLogCmd
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_error_log_ctrl(self):
""" Wrapper for executing error-log on controller.
def test_get_error_log(self):
""" Testcase main """
- assert_equal(self.get_error_log_ctrl(), 0)
+ self.assertEqual(self.get_error_log_ctrl(), 0)
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- Attributes:
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeFlushCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeFlushCmd """
- TestNVMe.__del__(self)
+ super().tearDown()
def nvme_flush(self):
""" Wrapper for nvme flush command.
def test_nvme_flush(self):
""" Testcase main """
- assert_equal(self.nvme_flush(), 0)
+ self.assertEqual(self.nvme_flush(), 0)
import subprocess
import time
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeFormatCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.dps = 0 # ns data protection settings
self.flbas = 0 # ns formattes logical block settings
self.nsze = 0x1400000 # ns size
self.delete_all_ns()
time.sleep(1)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeFormatCmd
- Atttach it to controller.
- Call super class's destructor.
"""
- assert_equal(self.create_and_validate_ns(self.default_nsid,
- self.nsze,
- self.ncap,
- self.flbas,
- self.dps), 0)
+ self.assertEqual(self.create_and_validate_ns(self.default_nsid,
+ self.nsze,
+ self.ncap,
+ self.flbas,
+ self.dps), 0)
self.attach_ns(self.ctrl_id, self.default_nsid)
- TestNVMe.__del__(self)
+ super().tearDown()
def attach_detach_primary_ns(self):
""" Extract supported format information using default namespace """
- assert_equal(self.create_and_validate_ns(self.default_nsid,
- self.nsze,
- self.ncap,
- self.flbas,
- self.dps), 0)
- assert_equal(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(self.create_and_validate_ns(self.default_nsid,
+ self.nsze,
+ self.ncap,
+ self.flbas,
+ self.dps), 0)
+ self.assertEqual(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
# read lbaf information
id_ns = "nvme id-ns " + self.ctrl + \
" -n1 | grep ^lbaf | awk '{print $2}' | tr -s \"\\n\" \" \""
proc = subprocess.Popen(id_ns, shell=True, stdout=subprocess.PIPE,
encoding='utf-8')
self.ms_list = proc.stdout.read().strip().split(" ")
- assert_equal(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
- assert_equal(self.delete_and_validate_ns(self.default_nsid), 0)
+ self.assertEqual(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(self.delete_and_validate_ns(self.default_nsid), 0)
self.nvme_reset_ctrl()
def test_format_ns(self):
self.ncap,
self.lba_format_list[i],
metadata_size)
- assert_equal(err, 0)
- assert_equal(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(err, 0)
+ self.assertEqual(self.attach_ns(self.ctrl_id, self.default_nsid), 0)
self.run_ns_io(self.default_nsid, self.lbads_list[i])
time.sleep(5)
- assert_equal(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
- assert_equal(self.delete_and_validate_ns(self.default_nsid), 0)
+ self.assertEqual(self.detach_ns(self.ctrl_id, self.default_nsid), 0)
+ self.assertEqual(self.delete_and_validate_ns(self.default_nsid), 0)
self.nvme_reset_ctrl()
import subprocess
-from nose.tools import assert_equal
from nvme_test import TestNVMe
Represents NVMe Firmware Log test.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeFwLogCmd. """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeSimpleTestTemplate.
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_fw_log(self):
""" Wrapper for executing nvme fw-log.
def test_fw_log(self):
""" Testcase main """
- assert_equal(self.get_fw_log(), 0)
+ self.assertEqual(self.get_fw_log(), 0)
import subprocess
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- vector_list_len : numer of the interrupt vectors.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeGetMandatoryFeatures """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
self.feature_id_list = ["0x01", "0x02", "0x04", "0x05", "0x07",
"0x08", "0x09", "0x0A", "0x0B"]
encoding='utf-8')
self.vector_list_len = len(proc.stdout.read().strip().split(" "))
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeGetMandatoryFeatures
Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_mandatory_features(self, feature_id):
""" Wrapper for NVMe get features command
encoding='utf-8')
feature_output = proc.communicate()[0]
print(feature_output)
- assert_equal(proc.wait(), 0)
+ self.assertEqual(proc.wait(), 0)
else:
get_feat_cmd = "nvme get-feature " + self.ctrl + \
" --feature-id=" + str(feature_id) + " -H"
encoding='utf-8')
feature_output = proc.communicate()[0]
print(feature_output)
- assert_equal(proc.wait(), 0)
+ self.assertEqual(proc.wait(), 0)
def test_get_mandatory_features(self):
""" Testcase main """
import subprocess
-from nose.tools import assert_equal
from nvme_test import TestNVMe
Represents Get LBA Status test.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeGetLbaStatusCmd. """
- TestNVMe.__init__(self)
+ super().setUp()
self.start_lba = 0
self.block_count = 0
self.namespace = 1
self.range_len = 1
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeGetLbaStatusCmd.
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_lba_status(self):
""" Wrapper for executing nvme get-lba-status.
def test_get_lba_status(self):
""" Testcase main """
- assert_equal(self.get_lba_status(), 0)
+ self.assertEqual(self.get_lba_status(), 0)
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
Represents Id ctrl testcase
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeIdctrlCmd. """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeIdctrlCmd
Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def test_id_ctrl(self):
""" Testcase main """
vendor = True
- assert_equal(self.get_id_ctrl(), 0)
- assert_equal(self.get_id_ctrl(vendor), 0)
+ self.assertEqual(self.get_id_ctrl(), 0)
+ self.assertEqual(self.get_id_ctrl(vendor), 0)
import subprocess
-from nose.tools import assert_equal
from nvme_test import TestNVMe
Represents Identify Namesepace testcase
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeIdentifyNamespace. """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
self.ns_list = self.get_ns_list()
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeIdentifyNamespace
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_id_ns(self, nsid):
"""
def test_id_ns(self):
""" Testcase main """
- assert_equal(self.get_id_ns(1), 0)
- assert_equal(self.get_id_ns_all(), 0)
+ self.assertEqual(self.get_id_ns(1), 0)
+ self.assertEqual(self.get_id_ns_all(), 0)
import subprocess
-from nose.tools import assert_equal
from nvme_test import TestNVMe
Represents LBA Status Log test.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeLbaStatLogCmd. """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeLbaStatLogCmd.
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_lba_stat_log(self):
""" Wrapper for executing nvme lba-status-log.
def test_lba_stat_log(self):
""" Testcase main """
- assert_equal(self.get_lba_stat_log(), 0)
+ self.assertEqual(self.get_lba_stat_log(), 0)
import filecmp
-from nose.tools import assert_equal
from nvme_test_io import TestNVMeIO
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeReadWriteTest """
- TestNVMeIO.__init__(self)
+ super().setUp()
self.start_block = 1023
self.test_log_dir = self.log_dir + "/" + self.__class__.__name__
self.setup_log_dir(self.__class__.__name__)
self.create_data_file(self.write_file, self.data_size, "15")
open(self.read_file, 'a').close()
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeReadWriteTest """
- TestNVMeIO.__del__(self)
+ super().tearDown()
def read_validate(self):
""" Validate the data file read
def test_nvme_write(self):
""" Testcaes main """
- assert_equal(self.nvme_write(), 0)
- assert_equal(self.nvme_read(), 0)
- assert_equal(self.read_validate(), 0)
+ self.assertEqual(self.nvme_write(), 0)
+ self.assertEqual(self.nvme_read(), 0)
+ self.assertEqual(self.read_validate(), 0)
""" Represents Simple NVMe test """
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeSimpleTestTemplate. """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
# Add this test specific variables here
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeSimpleTestTemplate
Call super class's destructor.
"""
# Add this test specific cleanup code here
- TestNVMe.__del__(self)
+ super().tearDown()
def simple_template_test(self):
""" Wrapper for this test specific functions
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- Attributes:
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeSmartLogCmd """
- TestNVMe.__init__(self)
+ super().setUp()
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
"""
Post Section for TestNVMeSmartLogCmd
- Call super class's destructor.
"""
- TestNVMe.__del__(self)
+ super().tearDown()
def get_smart_log_ctrl(self):
""" Wrapper for executing smart-log on controller.
def test_smart_log(self):
""" Testcase main """
- assert_equal(self.get_smart_log_ctrl(), 0)
+ self.assertEqual(self.get_smart_log_ctrl(), 0)
smlp = self.supp_check_id_ctrl("lpa")
if smlp & 0x1 == True:
- assert_equal(self.get_smart_log_all_ns(), 0)
+ self.assertEqual(self.get_smart_log_all_ns(), 0)
import subprocess
import sys
import time
+import unittest
-from nose import tools
-from nose.tools import assert_equal
from nvme_test_logger import TestNVMeLogger
-class TestNVMe(object):
+class TestNVMe(unittest.TestCase):
"""
Represents a testcase, each testcase shuold inherit this
- clear_log_dir : default log directory.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMe. """
# common code used in various testcases.
self.ctrl = "XXX"
self.ns1 = "XXX"
self.test_log_dir = "XXX"
self.default_nsid = 0x1
- self.config_file = 'config.json'
+ self.config_file = 'tests/config.json'
self.load_config()
self.validate_pci_device()
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMe. """
if self.clear_log_dir is True:
shutil.rmtree(self.log_dir, ignore_errors=True)
- @tools.nottest
def validate_pci_device(self):
""" Validate underlaying device belogs to pci subsystem.
- Args:
x1, x2, dev = self.ctrl.split('/')
cmd = cmd = "find /sys/devices -name \\*" + dev + " | grep -i pci"
err = subprocess.call(cmd, shell=True)
- assert_equal(err, 0, "ERROR : Only NVMe PCI subsystem is supported")
+ self.assertEqual(err, 0, "ERROR : Only NVMe PCI subsystem is supported")
- @tools.nottest
def load_config(self):
""" Load Basic test configuration.
- Args:
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir)
- @tools.nottest
def setup_log_dir(self, test_name):
""" Set up the log directory for a testcase
Args:
sys.stdout = TestNVMeLogger(self.test_log_dir + "/" + "stdout.log")
sys.stderr = TestNVMeLogger(self.test_log_dir + "/" + "stderr.log")
- @tools.nottest
def exec_cmd(self, cmd):
""" Wrapper for executing a shell command and return the result. """
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
encoding='utf-8')
return proc.wait()
- @tools.nottest
def nvme_reset_ctrl(self):
""" Wrapper for nvme reset command.
- Args:
shell=True,
stdout=subprocess.PIPE,
encoding='utf-8')
- assert_equal(err, 0, "ERROR : nvme reset failed")
+ self.assertEqual(err, 0, "ERROR : nvme reset failed")
time.sleep(5)
rescan_cmd = "echo 1 > /sys/bus/pci/rescan"
proc = subprocess.Popen(rescan_cmd,
stderr=subprocess.PIPE,
encoding='utf-8')
time.sleep(5)
- assert_equal(proc.wait(), 0, "ERROR : pci rescan failed")
+ self.assertEqual(proc.wait(), 0, "ERROR : pci rescan failed")
- @tools.nottest
def get_ctrl_id(self):
""" Wrapper for extracting the controller id.
- Args:
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : nvme list-ctrl failed")
+ self.assertEqual(err, 0, "ERROR : nvme list-ctrl failed")
line = proc.stdout.readline()
ctrl_id = line.split(":")[1].strip()
return ctrl_id
- @tools.nottest
def get_ns_list(self):
""" Wrapper for extrating the namespace list.
- Args:
shell=True,
stdout=subprocess.PIPE,
encoding='utf-8')
- assert_equal(proc.wait(), 0, "ERROR : nvme list namespace failed")
+ self.assertEqual(proc.wait(), 0, "ERROR : nvme list namespace failed")
for line in proc.stdout:
ns_list.append(line.split('x')[-1])
return ns_list
- @tools.nottest
def get_max_ns(self):
""" Wrapper for extracting maximum number of namspaces supported.
- Args:
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : reading maximum namespace count failed")
+ self.assertEqual(err, 0, "ERROR : reading maximum namespace count failed")
for line in proc.stdout:
if pattern.match(line):
print(max_ns)
return int(max_ns)
- @tools.nottest
def get_ncap(self):
""" Wrapper for extracting capacity.
- Args:
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : reading nvm capacity failed")
+ self.assertEqual(err, 0, "ERROR : reading nvm capacity failed")
for line in proc.stdout:
if pattern.match(line):
print(ncap)
return int(ncap)
- @tools.nottest
def get_format(self):
""" Wrapper for extracting format.
- Args:
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : reading nvm capacity failed")
+ self.assertEqual(err, 0, "ERROR : reading nvm capacity failed")
for line in proc.stdout:
if "in use" in line:
print(nvm_format)
return int(nvm_format)
- @tools.nottest
def delete_all_ns(self):
""" Wrapper for deleting all the namespaces.
- Args:
- None
"""
delete_ns_cmd = "nvme delete-ns " + self.ctrl + " -n 0xFFFFFFFF"
- assert_equal(self.exec_cmd(delete_ns_cmd), 0)
+ self.assertEqual(self.exec_cmd(delete_ns_cmd), 0)
list_ns_cmd = "nvme list-ns " + self.ctrl + " --all | wc -l"
proc = subprocess.Popen(list_ns_cmd,
shell=True,
stdout=subprocess.PIPE,
encoding='utf-8')
output = proc.stdout.read().strip()
- assert_equal(output, '0', "ERROR : deleting all namespace failed")
+ self.assertEqual(output, '0', "ERROR : deleting all namespace failed")
- @tools.nottest
def create_ns(self, nsze, ncap, flbas, dps):
""" Wrapper for creating a namespace.
- Args:
" --flbas=" + str(flbas) + " --dps=" + str(dps)
return self.exec_cmd(create_ns_cmd)
- @tools.nottest
def create_and_validate_ns(self, nsid, nsze, ncap, flbas, dps):
""" Wrapper for creating and validating a namespace.
- Args:
encoding='utf-8')
return err
- @tools.nottest
def attach_ns(self, ctrl_id, ns_id):
""" Wrapper for attaching the namespace.
- Args:
err = 0 if stat.S_ISBLK(os.stat(self.ns1).st_mode) else 1
return err
- @tools.nottest
def detach_ns(self, ctrl_id, nsid):
""" Wrapper for detaching the namespace.
- Args:
stdout=subprocess.PIPE,
encoding='utf-8')
- @tools.nottest
def delete_and_validate_ns(self, nsid):
""" Wrapper for deleting and validating that namespace is deleted.
- Args:
shell=True,
stdout=subprocess.PIPE,
encoding='utf-8')
- assert_equal(err, 0, "ERROR : delete namespace failed")
+ self.assertEqual(err, 0, "ERROR : delete namespace failed")
return err
def get_smart_log(self, nsid):
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : nvme smart log failed")
+ self.assertEqual(err, 0, "ERROR : nvme smart log failed")
for line in proc.stdout:
if "data_units_read" in line:
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : nvme id controller failed")
+ self.assertEqual(err, 0, "ERROR : nvme id controller failed")
return err
def get_error_log(self):
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : nvme error log failed")
+ self.assertEqual(err, 0, "ERROR : nvme error log failed")
line = proc.stdout.readline()
err_log_entry_count = int(line.split(" ")[5].strip().split(":")[1])
entry_count = 0
run_io = subprocess.Popen(io_cmd, shell=True, stdout=subprocess.PIPE,
encoding='utf-8')
run_io_result = run_io.communicate()[1]
- assert_equal(run_io_result, None)
+ self.assertEqual(run_io_result, None)
io_cmd = "dd if=/dev/zero of=" + ns_path + " bs=" + \
str(block_size) + " count=10 > /dev/null 2>&1"
print(io_cmd)
run_io = subprocess.Popen(io_cmd, shell=True, stdout=subprocess.PIPE,
encoding='utf-8')
run_io_result = run_io.communicate()[1]
- assert_equal(run_io_result, None)
+ self.assertEqual(run_io_result, None)
def supp_check_id_ctrl(self, key):
""" Wrapper for support check.
stdout=subprocess.PIPE,
encoding='utf-8')
err = proc.wait()
- assert_equal(err, 0, "ERROR : nvme Identify controller Data \
- structure failed")
+ self.assertEqual(err, 0, "ERROR : nvme Identify controller Data \
+ structure failed")
for line in proc.stdout:
if key in line:
key = line.replace(",", "", 1)
import os
-from nose import tools
from nvme_test import TestNVMe
- read_file : data file to use in nvme read command.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeIO """
- TestNVMe.__init__(self)
+ super().setUp()
# common code used in various testcases.
self.data_size = 512
self.start_block = 0
self.write_file = "write_file.txt"
self.read_file = "read_file.txt"
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeIO """
- TestNVMe.__del__(self)
+ super().tearDown()
- @tools.nottest
def create_data_file(self, pathname, data_size, pattern):
""" Creates data file with specific pattern
- Args:
os.fsync(data_file.fileno())
data_file.close()
- @tools.nottest
def nvme_write(self):
""" Wrapper for nvme write operation
- Args:
str(self.data_size) + " --data=" + self.write_file
return self.exec_cmd(write_cmd)
- @tools.nottest
def nvme_read(self):
""" Wrapper for nvme read operation
- Args:
import sys
-class TestNVMeLogger(object):
+class TestNVMeLogger():
""" Represents Logger for NVMe Testframework. """
def __init__(self, log_file_path):
"""
-from nose.tools import assert_equal
from nvme_test import TestNVMe
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeVerify """
- TestNVMe.__init__(self)
+ super().setUp()
self.start_block = 0
self.block_count = 0
self.namespace = 1
self.setup_log_dir(self.__class__.__name__)
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeVerify """
- TestNVMe.__del__(self)
+ super().tearDown()
def verify(self):
""" Wrapper for nvme verify
def test_verify(self):
""" Testcase main """
- assert_equal(self.verify(), 0)
+ self.assertEqual(self.verify(), 0)
"""
-from nose.tools import assert_equal, assert_not_equal
from nvme_test_io import TestNVMeIO
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Constructor TestNVMeUncor """
- TestNVMeIO.__init__(self)
+ super().setUp()
self.start_block = 1023
self.setup_log_dir(self.__class__.__name__)
self.write_file = self.test_log_dir + "/" + self.write_file
self.create_data_file(self.write_file, self.data_size, "15")
open(self.read_file, 'a').close()
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeUncor """
- TestNVMeIO.__del__(self)
+ super().tearDown()
def write_uncor(self):
""" Wrapper for nvme write uncorrectable
def test_write_uncor(self):
""" Testcase main """
- assert_equal(self.nvme_read(), 0)
- assert_equal(self.write_uncor(), 0)
- assert_not_equal(self.nvme_read(), 0)
- assert_equal(self.nvme_write(), 0)
- assert_equal(self.nvme_read(), 0)
+ self.assertEqual(self.nvme_read(), 0)
+ self.assertEqual(self.write_uncor(), 0)
+ self.assertNotEqual(self.nvme_read(), 0)
+ self.assertEqual(self.nvme_write(), 0)
+ self.assertEqual(self.nvme_read(), 0)
import filecmp
-from nose.tools import assert_equal
from nvme_test_io import TestNVMeIO
- test_log_dir : directory for logs, temp files.
"""
- def __init__(self):
+ def setUp(self):
""" Pre Section for TestNVMeWriteZeros """
- TestNVMeIO.__init__(self)
+ super().setUp()
self.start_block = 1023
self.block_count = 0
self.setup_log_dir(self.__class__.__name__)
self.create_data_file(self.zero_file, self.data_size, '\0')
open(self.read_file, 'a').close()
- def __del__(self):
+ def tearDown(self):
""" Post Section for TestNVMeWriteZeros """
- TestNVMeIO.__del__(self)
+ super().tearDown()
def write_zeroes(self):
""" Wrapper for nvme write-zeroe
def test_write_zeros(self):
""" Testcae main """
- assert_equal(self.nvme_write(), 0)
- assert_equal(self.nvme_read(), 0)
- assert_equal(self.validate_write_read(), 0)
- assert_equal(self.write_zeroes(), 0)
- assert_equal(self.nvme_read(), 0)
- assert_equal(self.validate_zeroes(), 0)
+ self.assertEqual(self.nvme_write(), 0)
+ self.assertEqual(self.nvme_read(), 0)
+ self.assertEqual(self.validate_write_read(), 0)
+ self.assertEqual(self.write_zeroes(), 0)
+ self.assertEqual(self.nvme_read(), 0)
+ self.assertEqual(self.validate_zeroes(), 0)
projects / users / sagi / nvme-cli.git / commitdiff