t/run-fio-tests.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0-only
   3 #
   4 # Copyright (c) 2019 Western Digital Corporation or its affiliates.
   5 #
   6 """
   7 # run-fio-tests.py
   8 #
   9 # Automate running of fio tests
  10 #
  11 # USAGE
  12 # python3 run-fio-tests.py [-r fio-root] [-f fio-path] [-a artifact-root]
  13 #                           [--skip # # #...] [--run-only # # #...]
  14 #
  15 #
  16 # EXAMPLE
  17 # # git clone git://git.kernel.dk/fio.git
  18 # # cd fio
  19 # # make -j
  20 # # python3 t/run-fio-tests.py
  21 #
  22 #
  23 # REQUIREMENTS
  24 # - Python 3.5 (subprocess.run)
  25 # - Linux (libaio ioengine, zbd tests, etc)
  26 # - The artifact directory must be on a file system that accepts 512-byte IO
  27 #   (t0002, t0003, t0004).
  28 # - The artifact directory needs to be on an SSD. Otherwise tests that carry
  29 #   out file-based IO will trigger a timeout (t0006).
  30 # - 4 CPUs (t0009)
  31 # - SciPy (steadystate_tests.py)
  32 # - libzbc (zbd tests)
  33 # - root privileges (zbd test)
  34 # - kernel 4.19 or later for zoned null block devices (zbd tests)
  35 # - CUnit support (unittests)
  36 #
  37 """
  38
  39 #
  40 # TODO  run multiple tests simultaneously
  41 # TODO  Add sgunmap tests (requires SAS SSD)
  42 #
  43
  44 import os
  45 import sys
  46 import json
  47 import time
  48 import shutil
  49 import logging
  50 import argparse
  51 import platform
  52 import traceback
  53 import subprocess
  54 import multiprocessing
  55 from pathlib import Path
  56
  57
  58 class FioTest():
  59     """Base for all fio tests."""
  60
  61     def __init__(self, exe_path, parameters, success):
  62         self.exe_path = exe_path
  63         self.parameters = parameters
  64         self.success = success
  65         self.output = {}
  66         self.artifact_root = None
  67         self.testnum = None
  68         self.test_dir = None
  69         self.passed = True
  70         self.failure_reason = ''
  71         self.command_file = None
  72         self.stdout_file = None
  73         self.stderr_file = None
  74         self.exitcode_file = None
  75
  76     def setup(self, artifact_root, testnum):
  77         """Setup instance variables for test."""
  78
  79         self.artifact_root = artifact_root
  80         self.testnum = testnum
  81         self.test_dir = os.path.join(artifact_root, "{:04d}".format(testnum))
  82         if not os.path.exists(self.test_dir):
  83             os.mkdir(self.test_dir)
  84
  85         self.command_file = os.path.join(
  86             self.test_dir,
  87             "{0}.command".format(os.path.basename(self.exe_path)))
  88         self.stdout_file = os.path.join(
  89             self.test_dir,
  90             "{0}.stdout".format(os.path.basename(self.exe_path)))
  91         self.stderr_file = os.path.join(
  92             self.test_dir,
  93             "{0}.stderr".format(os.path.basename(self.exe_path)))
  94         self.exitcode_file = os.path.join(
  95             self.test_dir,
  96             "{0}.exitcode".format(os.path.basename(self.exe_path)))
  97
  98     def run(self):
  99         """Run the test."""
 100
 101         raise NotImplementedError()
 102
 103     def check_result(self):
 104         """Check test results."""
 105
 106         raise NotImplementedError()
 107
 108
 109 class FioExeTest(FioTest):
 110     """Test consists of an executable binary or script"""
 111
 112     def __init__(self, exe_path, parameters, success):
 113         """Construct a FioExeTest which is a FioTest consisting of an
 114         executable binary or script.
 115
 116         exe_path:       location of executable binary or script
 117         parameters:     list of parameters for executable
 118         success:        Definition of test success
 119         """
 120
 121         FioTest.__init__(self, exe_path, parameters, success)
 122
 123     def run(self):
 124         """Execute the binary or script described by this instance."""
 125
 126         command = [self.exe_path] + self.parameters
 127         command_file = open(self.command_file, "w+")
 128         command_file.write("%s\n" % command)
 129         command_file.close()
 130
 131         stdout_file = open(self.stdout_file, "w+")
 132         stderr_file = open(self.stderr_file, "w+")
 133         exitcode_file = open(self.exitcode_file, "w+")
 134         try:
 135             proc = None
 136             # Avoid using subprocess.run() here because when a timeout occurs,
 137             # fio will be stopped with SIGKILL. This does not give fio a
 138             # chance to clean up and means that child processes may continue
 139             # running and submitting IO.
 140             proc = subprocess.Popen(command,
 141                                     stdout=stdout_file,
 142                                     stderr=stderr_file,
 143                                     cwd=self.test_dir,
 144                                     universal_newlines=True)
 145             proc.communicate(timeout=self.success['timeout'])
 146             exitcode_file.write('{0}\n'.format(proc.returncode))
 147             logging.debug("Test %d: return code: %d", self.testnum, proc.returncode)
 148             self.output['proc'] = proc
 149         except subprocess.TimeoutExpired:
 150             proc.terminate()
 151             proc.communicate()
 152             assert proc.poll()
 153             self.output['failure'] = 'timeout'
 154         except Exception:
 155             if proc:
 156                 if not proc.poll():
 157                     proc.terminate()
 158                     proc.communicate()
 159             self.output['failure'] = 'exception'
 160             self.output['exc_info'] = sys.exc_info()
 161         finally:
 162             stdout_file.close()
 163             stderr_file.close()
 164             exitcode_file.close()
 165
 166     def check_result(self):
 167         """Check results of test run."""
 168
 169         if 'proc' not in self.output:
 170             if self.output['failure'] == 'timeout':
 171                 self.failure_reason = "{0} timeout,".format(self.failure_reason)
 172             else:
 173                 assert self.output['failure'] == 'exception'
 174                 self.failure_reason = '{0} exception: {1}, {2}'.format(
 175                     self.failure_reason, self.output['exc_info'][0],
 176                     self.output['exc_info'][1])
 177
 178             self.passed = False
 179             return
 180
 181         if 'zero_return' in self.success:
 182             if self.success['zero_return']:
 183                 if self.output['proc'].returncode != 0:
 184                     self.passed = False
 185                     self.failure_reason = "{0} non-zero return code,".format(self.failure_reason)
 186             else:
 187                 if self.output['proc'].returncode == 0:
 188                     self.failure_reason = "{0} zero return code,".format(self.failure_reason)
 189                     self.passed = False
 190
 191         stderr_size = os.path.getsize(self.stderr_file)
 192         if 'stderr_empty' in self.success:
 193             if self.success['stderr_empty']:
 194                 if stderr_size != 0:
 195                     self.failure_reason = "{0} stderr not empty,".format(self.failure_reason)
 196                     self.passed = False
 197             else:
 198                 if stderr_size == 0:
 199                     self.failure_reason = "{0} stderr empty,".format(self.failure_reason)
 200                     self.passed = False
 201
 202
 203 class FioJobTest(FioExeTest):
 204     """Test consists of a fio job"""
 205
 206     def __init__(self, fio_path, fio_job, success, fio_pre_job=None,
 207                  fio_pre_success=None, output_format="normal"):
 208         """Construct a FioJobTest which is a FioExeTest consisting of a
 209         single fio job file with an optional setup step.
 210
 211         fio_path:           location of fio executable
 212         fio_job:            location of fio job file
 213         success:            Definition of test success
 214         fio_pre_job:        fio job for preconditioning
 215         fio_pre_success:    Definition of test success for fio precon job
 216         output_format:      normal (default), json, jsonplus, or terse
 217         """
 218
 219         self.fio_job = fio_job
 220         self.fio_pre_job = fio_pre_job
 221         self.fio_pre_success = fio_pre_success if fio_pre_success else success
 222         self.output_format = output_format
 223         self.precon_failed = False
 224         self.json_data = None
 225         self.fio_output = "{0}.output".format(os.path.basename(self.fio_job))
 226         self.fio_args = [
 227             "--max-jobs=16",
 228             "--output-format={0}".format(self.output_format),
 229             "--output={0}".format(self.fio_output),
 230             self.fio_job,
 231             ]
 232         FioExeTest.__init__(self, fio_path, self.fio_args, success)
 233
 234     def setup(self, artifact_root, testnum):
 235         """Setup instance variables for fio job test."""
 236
 237         super(FioJobTest, self).setup(artifact_root, testnum)
 238
 239         self.command_file = os.path.join(
 240             self.test_dir,
 241             "{0}.command".format(os.path.basename(self.fio_job)))
 242         self.stdout_file = os.path.join(
 243             self.test_dir,
 244             "{0}.stdout".format(os.path.basename(self.fio_job)))
 245         self.stderr_file = os.path.join(
 246             self.test_dir,
 247             "{0}.stderr".format(os.path.basename(self.fio_job)))
 248         self.exitcode_file = os.path.join(
 249             self.test_dir,
 250             "{0}.exitcode".format(os.path.basename(self.fio_job)))
 251
 252     def run_pre_job(self):
 253         """Run fio job precondition step."""
 254
 255         precon = FioJobTest(self.exe_path, self.fio_pre_job,
 256                             self.fio_pre_success,
 257                             output_format=self.output_format)
 258         precon.setup(self.artifact_root, self.testnum)
 259         precon.run()
 260         precon.check_result()
 261         self.precon_failed = not precon.passed
 262         self.failure_reason = precon.failure_reason
 263
 264     def run(self):
 265         """Run fio job test."""
 266
 267         if self.fio_pre_job:
 268             self.run_pre_job()
 269
 270         if not self.precon_failed:
 271             super(FioJobTest, self).run()
 272         else:
 273             logging.debug("Test %d: precondition step failed", self.testnum)
 274
 275     @classmethod
 276     def get_file(cls, filename):
 277         """Safely read a file."""
 278         file_data = ''
 279         success = True
 280
 281         try:
 282             with open(filename, "r") as output_file:
 283                 file_data = output_file.read()
 284         except OSError:
 285             success = False
 286
 287         return file_data, success
 288
 289     def get_file_fail(self, filename):
 290         """Safely read a file and fail the test upon error."""
 291         file_data = None
 292
 293         try:
 294             with open(filename, "r") as output_file:
 295                 file_data = output_file.read()
 296         except OSError:
 297             self.failure_reason += " unable to read file {0}".format(filename)
 298             self.passed = False
 299
 300         return file_data
 301
 302     def check_result(self):
 303         """Check fio job results."""
 304
 305         if self.precon_failed:
 306             self.passed = False
 307             self.failure_reason = "{0} precondition step failed,".format(self.failure_reason)
 308             return
 309
 310         super(FioJobTest, self).check_result()
 311
 312         if not self.passed:
 313             return
 314
 315         if 'json' not in self.output_format:
 316             return
 317
 318         file_data = self.get_file_fail(os.path.join(self.test_dir, self.fio_output))
 319         if not file_data:
 320             return
 321
 322         #
 323         # Sometimes fio informational messages are included at the top of the
 324         # JSON output, especially under Windows. Try to decode output as JSON
 325         # data, skipping everything until the first {
 326         #
 327         lines = file_data.splitlines()
 328         file_data = '\n'.join(lines[lines.index("{"):])
 329         try:
 330             self.json_data = json.loads(file_data)
 331         except json.JSONDecodeError:
 332             self.failure_reason = "{0} unable to decode JSON data,".format(self.failure_reason)
 333             self.passed = False
 334
 335
 336 class FioJobTest_t0005(FioJobTest):
 337     """Test consists of fio test job t0005
 338     Confirm that read['io_kbytes'] == write['io_kbytes'] == 102400"""
 339
 340     def check_result(self):
 341         super(FioJobTest_t0005, self).check_result()
 342
 343         if not self.passed:
 344             return
 345
 346         if self.json_data['jobs'][0]['read']['io_kbytes'] != 102400:
 347             self.failure_reason = "{0} bytes read mismatch,".format(self.failure_reason)
 348             self.passed = False
 349         if self.json_data['jobs'][0]['write']['io_kbytes'] != 102400:
 350             self.failure_reason = "{0} bytes written mismatch,".format(self.failure_reason)
 351             self.passed = False
 352
 353
 354 class FioJobTest_t0006(FioJobTest):
 355     """Test consists of fio test job t0006
 356     Confirm that read['io_kbytes'] ~ 2*write['io_kbytes']"""
 357
 358     def check_result(self):
 359         super(FioJobTest_t0006, self).check_result()
 360
 361         if not self.passed:
 362             return
 363
 364         ratio = self.json_data['jobs'][0]['read']['io_kbytes'] \
 365             / self.json_data['jobs'][0]['write']['io_kbytes']
 366         logging.debug("Test %d: ratio: %f", self.testnum, ratio)
 367         if ratio < 1.99 or ratio > 2.01:
 368             self.failure_reason = "{0} read/write ratio mismatch,".format(self.failure_reason)
 369             self.passed = False
 370
 371
 372 class FioJobTest_t0007(FioJobTest):
 373     """Test consists of fio test job t0007
 374     Confirm that read['io_kbytes'] = 87040"""
 375
 376     def check_result(self):
 377         super(FioJobTest_t0007, self).check_result()
 378
 379         if not self.passed:
 380             return
 381
 382         if self.json_data['jobs'][0]['read']['io_kbytes'] != 87040:
 383             self.failure_reason = "{0} bytes read mismatch,".format(self.failure_reason)
 384             self.passed = False
 385
 386
 387 class FioJobTest_t0008(FioJobTest):
 388     """Test consists of fio test job t0008
 389     Confirm that read['io_kbytes'] = 32768 and that
 390                 write['io_kbytes'] ~ 16568
 391
 392     I did runs with fio-ae2fafc8 and saw write['io_kbytes'] values of
 393     16585, 16588. With two runs of fio-3.16 I obtained 16568"""
 394
 395     def check_result(self):
 396         super(FioJobTest_t0008, self).check_result()
 397
 398         if not self.passed:
 399             return
 400
 401         ratio = self.json_data['jobs'][0]['write']['io_kbytes'] / 16568
 402         logging.debug("Test %d: ratio: %f", self.testnum, ratio)
 403
 404         if ratio < 0.99 or ratio > 1.01:
 405             self.failure_reason = "{0} bytes written mismatch,".format(self.failure_reason)
 406             self.passed = False
 407         if self.json_data['jobs'][0]['read']['io_kbytes'] != 32768:
 408             self.failure_reason = "{0} bytes read mismatch,".format(self.failure_reason)
 409             self.passed = False
 410
 411
 412 class FioJobTest_t0009(FioJobTest):
 413     """Test consists of fio test job t0009
 414     Confirm that runtime >= 60s"""
 415
 416     def check_result(self):
 417         super(FioJobTest_t0009, self).check_result()
 418
 419         if not self.passed:
 420             return
 421
 422         logging.debug('Test %d: elapsed: %d', self.testnum, self.json_data['jobs'][0]['elapsed'])
 423
 424         if self.json_data['jobs'][0]['elapsed'] < 60:
 425             self.failure_reason = "{0} elapsed time mismatch,".format(self.failure_reason)
 426             self.passed = False
 427
 428
 429 class FioJobTest_t0012(FioJobTest):
 430     """Test consists of fio test job t0012
 431     Confirm ratios of job iops are 1:5:10
 432     job1,job2,job3 respectively"""
 433
 434     def check_result(self):
 435         super(FioJobTest_t0012, self).check_result()
 436
 437         if not self.passed:
 438             return
 439
 440         iops_files = []
 441         for i in range(1, 4):
 442             filename = os.path.join(self.test_dir, "{0}_iops.{1}.log".format(os.path.basename(
 443                 self.fio_job), i))
 444             file_data = self.get_file_fail(filename)
 445             if not file_data:
 446                 return
 447
 448             iops_files.append(file_data.splitlines())
 449
 450         # there are 9 samples for job1 and job2, 4 samples for job3
 451         iops1 = 0.0
 452         iops2 = 0.0
 453         iops3 = 0.0
 454         for i in range(9):
 455             iops1 = iops1 + float(iops_files[0][i].split(',')[1])
 456             iops2 = iops2 + float(iops_files[1][i].split(',')[1])
 457             iops3 = iops3 + float(iops_files[2][i].split(',')[1])
 458
 459             ratio1 = iops3/iops2
 460             ratio2 = iops3/iops1
 461             logging.debug("sample {0}: job1 iops={1} job2 iops={2} job3 iops={3} " \
 462                 "job3/job2={4:.3f} job3/job1={5:.3f}".format(i, iops1, iops2, iops3, ratio1,
 463                                                              ratio2))
 464
 465         # test job1 and job2 succeeded to recalibrate
 466         if ratio1 < 1 or ratio1 > 3 or ratio2 < 7 or ratio2 > 13:
 467             self.failure_reason += " iops ratio mismatch iops1={0} iops2={1} iops3={2} " \
 468                 "expected r1~2 r2~10 got r1={3:.3f} r2={4:.3f},".format(iops1, iops2, iops3,
 469                                                                         ratio1, ratio2)
 470             self.passed = False
 471             return
 472
 473
 474 class FioJobTest_t0014(FioJobTest):
 475     """Test consists of fio test job t0014
 476         Confirm that job1_iops / job2_iops ~ 1:2 for entire duration
 477         and that job1_iops / job3_iops ~ 1:3 for first half of duration.
 478
 479     The test is about making sure the flow feature can
 480     re-calibrate the activity dynamically"""
 481
 482     def check_result(self):
 483         super(FioJobTest_t0014, self).check_result()
 484
 485         if not self.passed:
 486             return
 487
 488         iops_files = []
 489         for i in range(1, 4):
 490             filename = os.path.join(self.test_dir, "{0}_iops.{1}.log".format(os.path.basename(
 491                 self.fio_job), i))
 492             file_data = self.get_file_fail(filename)
 493             if not file_data:
 494                 return
 495
 496             iops_files.append(file_data.splitlines())
 497
 498         # there are 9 samples for job1 and job2, 4 samples for job3
 499         iops1 = 0.0
 500         iops2 = 0.0
 501         iops3 = 0.0
 502         for i in range(9):
 503             if i < 4:
 504                 iops3 = iops3 + float(iops_files[2][i].split(',')[1])
 505             elif i == 4:
 506                 ratio1 = iops1 / iops2
 507                 ratio2 = iops1 / iops3
 508
 509
 510                 if ratio1 < 0.43 or ratio1 > 0.57 or ratio2 < 0.21 or ratio2 > 0.45:
 511                     self.failure_reason += " iops ratio mismatch iops1={0} iops2={1} iops3={2} " \
 512                                            "expected r1~0.5 r2~0.33 got r1={3:.3f} r2={4:.3f},".format(
 513                                                iops1, iops2, iops3, ratio1, ratio2)
 514                     self.passed = False
 515
 516             iops1 = iops1 + float(iops_files[0][i].split(',')[1])
 517             iops2 = iops2 + float(iops_files[1][i].split(',')[1])
 518
 519             ratio1 = iops1/iops2
 520             ratio2 = iops1/iops3
 521             logging.debug("sample {0}: job1 iops={1} job2 iops={2} job3 iops={3} " \
 522                           "job1/job2={4:.3f} job1/job3={5:.3f}".format(i, iops1, iops2, iops3,
 523                                                                        ratio1, ratio2))
 524
 525         # test job1 and job2 succeeded to recalibrate
 526         if ratio1 < 0.43 or ratio1 > 0.57:
 527             self.failure_reason += " iops ratio mismatch iops1={0} iops2={1} expected ratio~0.5 " \
 528                                    "got ratio={2:.3f},".format(iops1, iops2, ratio1)
 529             self.passed = False
 530             return
 531
 532
 533 class FioJobTest_t0015(FioJobTest):
 534     """Test consists of fio test jobs t0015 and t0016
 535     Confirm that mean(slat) + mean(clat) = mean(tlat)"""
 536
 537     def check_result(self):
 538         super(FioJobTest_t0015, self).check_result()
 539
 540         if not self.passed:
 541             return
 542
 543         slat = self.json_data['jobs'][0]['read']['slat_ns']['mean']
 544         clat = self.json_data['jobs'][0]['read']['clat_ns']['mean']
 545         tlat = self.json_data['jobs'][0]['read']['lat_ns']['mean']
 546         logging.debug('Test %d: slat %f, clat %f, tlat %f', self.testnum, slat, clat, tlat)
 547
 548         if abs(slat + clat - tlat) > 1:
 549             self.failure_reason = "{0} slat {1} + clat {2} = {3} != tlat {4},".format(
 550                 self.failure_reason, slat, clat, slat+clat, tlat)
 551             self.passed = False
 552
 553
 554 class FioJobTest_t0019(FioJobTest):
 555     """Test consists of fio test job t0019
 556     Confirm that all offsets were touched sequentially"""
 557
 558     def check_result(self):
 559         super(FioJobTest_t0019, self).check_result()
 560
 561         bw_log_filename = os.path.join(self.test_dir, "test_bw.log")
 562         file_data = self.get_file_fail(bw_log_filename)
 563         if not file_data:
 564             return
 565
 566         log_lines = file_data.split('\n')
 567
 568         prev = -4096
 569         for line in log_lines:
 570             if len(line.strip()) == 0:
 571                 continue
 572             cur = int(line.split(',')[4])
 573             if cur - prev != 4096:
 574                 self.passed = False
 575                 self.failure_reason = "offsets {0}, {1} not sequential".format(prev, cur)
 576                 return
 577             prev = cur
 578
 579         if cur/4096 != 255:
 580             self.passed = False
 581             self.failure_reason = "unexpected last offset {0}".format(cur)
 582
 583
 584 class FioJobTest_t0020(FioJobTest):
 585     """Test consists of fio test jobs t0020 and t0021
 586     Confirm that almost all offsets were touched non-sequentially"""
 587
 588     def check_result(self):
 589         super(FioJobTest_t0020, self).check_result()
 590
 591         bw_log_filename = os.path.join(self.test_dir, "test_bw.log")
 592         file_data = self.get_file_fail(bw_log_filename)
 593         if not file_data:
 594             return
 595
 596         log_lines = file_data.split('\n')
 597
 598         seq_count = 0
 599         offsets = set()
 600
 601         prev = int(log_lines[0].split(',')[4])
 602         for line in log_lines[1:]:
 603             offsets.add(prev/4096)
 604             if len(line.strip()) == 0:
 605                 continue
 606             cur = int(line.split(',')[4])
 607             if cur - prev == 4096:
 608                 seq_count += 1
 609             prev = cur
 610
 611         # 10 is an arbitrary threshold
 612         if seq_count > 10:
 613             self.passed = False
 614             self.failure_reason = "too many ({0}) consecutive offsets".format(seq_count)
 615
 616         if len(offsets) != 256:
 617             self.passed = False
 618             self.failure_reason += " number of offsets is {0} instead of 256".format(len(offsets))
 619
 620         for i in range(256):
 621             if not i in offsets:
 622                 self.passed = False
 623                 self.failure_reason += " missing offset {0}".format(i*4096)
 624
 625
 626 class FioJobTest_t0022(FioJobTest):
 627     """Test consists of fio test job t0022"""
 628
 629     def check_result(self):
 630         super(FioJobTest_t0022, self).check_result()
 631
 632         bw_log_filename = os.path.join(self.test_dir, "test_bw.log")
 633         file_data = self.get_file_fail(bw_log_filename)
 634         if not file_data:
 635             return
 636
 637         log_lines = file_data.split('\n')
 638
 639         filesize = 1024*1024
 640         bs = 4096
 641         seq_count = 0
 642         offsets = set()
 643
 644         prev = int(log_lines[0].split(',')[4])
 645         for line in log_lines[1:]:
 646             offsets.add(prev/bs)
 647             if len(line.strip()) == 0:
 648                 continue
 649             cur = int(line.split(',')[4])
 650             if cur - prev == bs:
 651                 seq_count += 1
 652             prev = cur
 653
 654         # 10 is an arbitrary threshold
 655         if seq_count > 10:
 656             self.passed = False
 657             self.failure_reason = "too many ({0}) consecutive offsets".format(seq_count)
 658
 659         if len(offsets) == filesize/bs:
 660             self.passed = False
 661             self.failure_reason += " no duplicate offsets found with norandommap=1"
 662
 663
 664 class FioJobTest_t0023(FioJobTest):
 665     """Test consists of fio test job t0023 randtrimwrite test."""
 666
 667     def check_trimwrite(self, filename):
 668         """Make sure that trims are followed by writes of the same size at the same offset."""
 669
 670         bw_log_filename = os.path.join(self.test_dir, filename)
 671         file_data = self.get_file_fail(bw_log_filename)
 672         if not file_data:
 673             return
 674
 675         log_lines = file_data.split('\n')
 676
 677         prev_ddir = 1
 678         for line in log_lines:
 679             if len(line.strip()) == 0:
 680                 continue
 681             vals = line.split(',')
 682             ddir = int(vals[2])
 683             bs = int(vals[3])
 684             offset = int(vals[4])
 685             if prev_ddir == 1:
 686                 if ddir != 2:
 687                     self.passed = False
 688                     self.failure_reason += " {0}: write not preceeded by trim: {1}".format(
 689                         bw_log_filename, line)
 690                     break
 691             else:
 692                 if ddir != 1:
 693                     self.passed = False
 694                     self.failure_reason += " {0}: trim not preceeded by write: {1}".format(
 695                         bw_log_filename, line)
 696                     break
 697                 else:
 698                     if prev_bs != bs:
 699                         self.passed = False
 700                         self.failure_reason += " {0}: block size does not match: {1}".format(
 701                             bw_log_filename, line)
 702                         break
 703                     if prev_offset != offset:
 704                         self.passed = False
 705                         self.failure_reason += " {0}: offset does not match: {1}".format(
 706                             bw_log_filename, line)
 707                         break
 708             prev_ddir = ddir
 709             prev_bs = bs
 710             prev_offset = offset
 711
 712
 713     def check_all_offsets(self, filename, sectorsize, filesize):
 714         """Make sure all offsets were touched."""
 715
 716         file_data = self.get_file_fail(os.path.join(self.test_dir, filename))
 717         if not file_data:
 718             return
 719
 720         log_lines = file_data.split('\n')
 721
 722         offsets = set()
 723
 724         for line in log_lines:
 725             if len(line.strip()) == 0:
 726                 continue
 727             vals = line.split(',')
 728             bs = int(vals[3])
 729             offset = int(vals[4])
 730             if offset % sectorsize != 0:
 731                 self.passed = False
 732                 self.failure_reason += " {0}: offset {1} not a multiple of sector size {2}".format(
 733                     filename, offset, sectorsize)
 734                 break
 735             if bs % sectorsize != 0:
 736                 self.passed = False
 737                 self.failure_reason += " {0}: block size {1} not a multiple of sector size " \
 738                     "{2}".format(filename, bs, sectorsize)
 739                 break
 740             for i in range(int(bs/sectorsize)):
 741                 offsets.add(offset/sectorsize + i)
 742
 743         if len(offsets) != filesize/sectorsize:
 744             self.passed = False
 745             self.failure_reason += " {0}: only {1} offsets touched; expected {2}".format(
 746                 filename, len(offsets), filesize/sectorsize)
 747         else:
 748             logging.debug("%s: %d sectors touched", filename, len(offsets))
 749
 750
 751     def check_result(self):
 752         super(FioJobTest_t0023, self).check_result()
 753
 754         filesize = 1024*1024
 755
 756         self.check_trimwrite("basic_bw.log")
 757         self.check_trimwrite("bs_bw.log")
 758         self.check_trimwrite("bsrange_bw.log")
 759         self.check_trimwrite("bssplit_bw.log")
 760         self.check_trimwrite("basic_no_rm_bw.log")
 761         self.check_trimwrite("bs_no_rm_bw.log")
 762         self.check_trimwrite("bsrange_no_rm_bw.log")
 763         self.check_trimwrite("bssplit_no_rm_bw.log")
 764
 765         self.check_all_offsets("basic_bw.log", 4096, filesize)
 766         self.check_all_offsets("bs_bw.log", 8192, filesize)
 767         self.check_all_offsets("bsrange_bw.log", 512, filesize)
 768         self.check_all_offsets("bssplit_bw.log", 512, filesize)
 769
 770
 771 class FioJobTest_t0024(FioJobTest_t0023):
 772     """Test consists of fio test job t0024 trimwrite test."""
 773
 774     def check_result(self):
 775         # call FioJobTest_t0023's parent to skip checks done by t0023
 776         super(FioJobTest_t0023, self).check_result()
 777
 778         filesize = 1024*1024
 779
 780         self.check_trimwrite("basic_bw.log")
 781         self.check_trimwrite("bs_bw.log")
 782         self.check_trimwrite("bsrange_bw.log")
 783         self.check_trimwrite("bssplit_bw.log")
 784
 785         self.check_all_offsets("basic_bw.log", 4096, filesize)
 786         self.check_all_offsets("bs_bw.log", 8192, filesize)
 787         self.check_all_offsets("bsrange_bw.log", 512, filesize)
 788         self.check_all_offsets("bssplit_bw.log", 512, filesize)
 789
 790
 791 class FioJobTest_iops_rate(FioJobTest):
 792     """Test consists of fio test job t0009
 793     Confirm that job0 iops == 1000
 794     and that job1_iops / job0_iops ~ 8
 795     With two runs of fio-3.16 I observed a ratio of 8.3"""
 796
 797     def check_result(self):
 798         super(FioJobTest_iops_rate, self).check_result()
 799
 800         if not self.passed:
 801             return
 802
 803         iops1 = self.json_data['jobs'][0]['read']['iops']
 804         logging.debug("Test %d: iops1: %f", self.testnum, iops1)
 805         iops2 = self.json_data['jobs'][1]['read']['iops']
 806         logging.debug("Test %d: iops2: %f", self.testnum, iops2)
 807         ratio = iops2 / iops1
 808         logging.debug("Test %d: ratio: %f", self.testnum, ratio)
 809
 810         if iops1 < 950 or iops1 > 1050:
 811             self.failure_reason = "{0} iops value mismatch,".format(self.failure_reason)
 812             self.passed = False
 813
 814         if ratio < 6 or ratio > 10:
 815             self.failure_reason = "{0} iops ratio mismatch,".format(self.failure_reason)
 816             self.passed = False
 817
 818
 819 class Requirements():
 820     """Requirements consists of multiple run environment characteristics.
 821     These are to determine if a particular test can be run"""
 822
 823     _linux = False
 824     _libaio = False
 825     _io_uring = False
 826     _zbd = False
 827     _root = False
 828     _zoned_nullb = False
 829     _not_macos = False
 830     _not_windows = False
 831     _unittests = False
 832     _cpucount4 = False
 833
 834     def __init__(self, fio_root):
 835         Requirements._not_macos = platform.system() != "Darwin"
 836         Requirements._not_windows = platform.system() != "Windows"
 837         Requirements._linux = platform.system() == "Linux"
 838
 839         if Requirements._linux:
 840             config_file = os.path.join(fio_root, "config-host.h")
 841             contents, success = FioJobTest.get_file(config_file)
 842             if not success:
 843                 print("Unable to open {0} to check requirements".format(config_file))
 844                 Requirements._zbd = True
 845             else:
 846                 Requirements._zbd = "CONFIG_HAS_BLKZONED" in contents
 847                 Requirements._libaio = "CONFIG_LIBAIO" in contents
 848
 849             contents, success = FioJobTest.get_file("/proc/kallsyms")
 850             if not success:
 851                 print("Unable to open '/proc/kallsyms' to probe for io_uring support")
 852             else:
 853                 Requirements._io_uring = "io_uring_setup" in contents
 854
 855             Requirements._root = (os.geteuid() == 0)
 856             if Requirements._zbd and Requirements._root:
 857                 try:
 858                     subprocess.run(["modprobe", "null_blk"],
 859                                    stdout=subprocess.PIPE,
 860                                    stderr=subprocess.PIPE)
 861                     if os.path.exists("/sys/module/null_blk/parameters/zoned"):
 862                         Requirements._zoned_nullb = True
 863                 except Exception:
 864                     pass
 865
 866         if platform.system() == "Windows":
 867             utest_exe = "unittest.exe"
 868         else:
 869             utest_exe = "unittest"
 870         unittest_path = os.path.join(fio_root, "unittests", utest_exe)
 871         Requirements._unittests = os.path.exists(unittest_path)
 872
 873         Requirements._cpucount4 = multiprocessing.cpu_count() >= 4
 874
 875         req_list = [Requirements.linux,
 876                     Requirements.libaio,
 877                     Requirements.io_uring,
 878                     Requirements.zbd,
 879                     Requirements.root,
 880                     Requirements.zoned_nullb,
 881                     Requirements.not_macos,
 882                     Requirements.not_windows,
 883                     Requirements.unittests,
 884                     Requirements.cpucount4]
 885         for req in req_list:
 886             value, desc = req()
 887             logging.debug("Requirements: Requirement '%s' met? %s", desc, value)
 888
 889     @classmethod
 890     def linux(cls):
 891         """Are we running on Linux?"""
 892         return Requirements._linux, "Linux required"
 893
 894     @classmethod
 895     def libaio(cls):
 896         """Is libaio available?"""
 897         return Requirements._libaio, "libaio required"
 898
 899     @classmethod
 900     def io_uring(cls):
 901         """Is io_uring available?"""
 902         return Requirements._io_uring, "io_uring required"
 903
 904     @classmethod
 905     def zbd(cls):
 906         """Is ZBD support available?"""
 907         return Requirements._zbd, "Zoned block device support required"
 908
 909     @classmethod
 910     def root(cls):
 911         """Are we running as root?"""
 912         return Requirements._root, "root required"
 913
 914     @classmethod
 915     def zoned_nullb(cls):
 916         """Are zoned null block devices available?"""
 917         return Requirements._zoned_nullb, "Zoned null block device support required"
 918
 919     @classmethod
 920     def not_macos(cls):
 921         """Are we running on a platform other than macOS?"""
 922         return Requirements._not_macos, "platform other than macOS required"
 923
 924     @classmethod
 925     def not_windows(cls):
 926         """Are we running on a platform other than Windws?"""
 927         return Requirements._not_windows, "platform other than Windows required"
 928
 929     @classmethod
 930     def unittests(cls):
 931         """Were unittests built?"""
 932         return Requirements._unittests, "Unittests support required"
 933
 934     @classmethod
 935     def cpucount4(cls):
 936         """Do we have at least 4 CPUs?"""
 937         return Requirements._cpucount4, "4+ CPUs required"
 938
 939
 940 SUCCESS_DEFAULT = {
 941     'zero_return': True,
 942     'stderr_empty': True,
 943     'timeout': 600,
 944     }
 945 SUCCESS_NONZERO = {
 946     'zero_return': False,
 947     'stderr_empty': False,
 948     'timeout': 600,
 949     }
 950 SUCCESS_STDERR = {
 951     'zero_return': True,
 952     'stderr_empty': False,
 953     'timeout': 600,
 954     }
 955 TEST_LIST = [
 956     {
 957         'test_id':          1,
 958         'test_class':       FioJobTest,
 959         'job':              't0001-52c58027.fio',
 960         'success':          SUCCESS_DEFAULT,
 961         'pre_job':          None,
 962         'pre_success':      None,
 963         'requirements':     [],
 964     },
 965     {
 966         'test_id':          2,
 967         'test_class':       FioJobTest,
 968         'job':              't0002-13af05ae-post.fio',
 969         'success':          SUCCESS_DEFAULT,
 970         'pre_job':          't0002-13af05ae-pre.fio',
 971         'pre_success':      None,
 972         'requirements':     [Requirements.linux, Requirements.libaio],
 973     },
 974     {
 975         'test_id':          3,
 976         'test_class':       FioJobTest,
 977         'job':              't0003-0ae2c6e1-post.fio',
 978         'success':          SUCCESS_NONZERO,
 979         'pre_job':          't0003-0ae2c6e1-pre.fio',
 980         'pre_success':      SUCCESS_DEFAULT,
 981         'requirements':     [Requirements.linux, Requirements.libaio],
 982     },
 983     {
 984         'test_id':          4,
 985         'test_class':       FioJobTest,
 986         'job':              't0004-8a99fdf6.fio',
 987         'success':          SUCCESS_DEFAULT,
 988         'pre_job':          None,
 989         'pre_success':      None,
 990         'requirements':     [Requirements.linux, Requirements.libaio],
 991     },
 992     {
 993         'test_id':          5,
 994         'test_class':       FioJobTest_t0005,
 995         'job':              't0005-f7078f7b.fio',
 996         'success':          SUCCESS_DEFAULT,
 997         'pre_job':          None,
 998         'pre_success':      None,
 999         'output_format':    'json',
1000         'requirements':     [Requirements.not_windows],
1001     },
1002     {
1003         'test_id':          6,
1004         'test_class':       FioJobTest_t0006,
1005         'job':              't0006-82af2a7c.fio',
1006         'success':          SUCCESS_DEFAULT,
1007         'pre_job':          None,
1008         'pre_success':      None,
1009         'output_format':    'json',
1010         'requirements':     [Requirements.linux, Requirements.libaio],
1011     },
1012     {
1013         'test_id':          7,
1014         'test_class':       FioJobTest_t0007,
1015         'job':              't0007-37cf9e3c.fio',
1016         'success':          SUCCESS_DEFAULT,
1017         'pre_job':          None,
1018         'pre_success':      None,
1019         'output_format':    'json',
1020         'requirements':     [],
1021     },
1022     {
1023         'test_id':          8,
1024         'test_class':       FioJobTest_t0008,
1025         'job':              't0008-ae2fafc8.fio',
1026         'success':          SUCCESS_DEFAULT,
1027         'pre_job':          None,
1028         'pre_success':      None,
1029         'output_format':    'json',
1030         'requirements':     [],
1031     },
1032     {
1033         'test_id':          9,
1034         'test_class':       FioJobTest_t0009,
1035         'job':              't0009-f8b0bd10.fio',
1036         'success':          SUCCESS_DEFAULT,
1037         'pre_job':          None,
1038         'pre_success':      None,
1039         'output_format':    'json',
1040         'requirements':     [Requirements.not_macos,
1041                              Requirements.cpucount4],
1042         # mac os does not support CPU affinity
1043     },
1044     {
1045         'test_id':          10,
1046         'test_class':       FioJobTest,
1047         'job':              't0010-b7aae4ba.fio',
1048         'success':          SUCCESS_DEFAULT,
1049         'pre_job':          None,
1050         'pre_success':      None,
1051         'requirements':     [],
1052     },
1053     {
1054         'test_id':          11,
1055         'test_class':       FioJobTest_iops_rate,
1056         'job':              't0011-5d2788d5.fio',
1057         'success':          SUCCESS_DEFAULT,
1058         'pre_job':          None,
1059         'pre_success':      None,
1060         'output_format':    'json',
1061         'requirements':     [],
1062     },
1063     {
1064         'test_id':          12,
1065         'test_class':       FioJobTest_t0012,
1066         'job':              't0012.fio',
1067         'success':          SUCCESS_DEFAULT,
1068         'pre_job':          None,
1069         'pre_success':      None,
1070         'output_format':    'json',
1071         'requirements':     [],
1072     },
1073     {
1074         'test_id':          13,
1075         'test_class':       FioJobTest,
1076         'job':              't0013.fio',
1077         'success':          SUCCESS_DEFAULT,
1078         'pre_job':          None,
1079         'pre_success':      None,
1080         'output_format':    'json',
1081         'requirements':     [],
1082     },
1083     {
1084         'test_id':          14,
1085         'test_class':       FioJobTest_t0014,
1086         'job':              't0014.fio',
1087         'success':          SUCCESS_DEFAULT,
1088         'pre_job':          None,
1089         'pre_success':      None,
1090         'output_format':    'json',
1091         'requirements':     [],
1092     },
1093     {
1094         'test_id':          15,
1095         'test_class':       FioJobTest_t0015,
1096         'job':              't0015-e78980ff.fio',
1097         'success':          SUCCESS_DEFAULT,
1098         'pre_job':          None,
1099         'pre_success':      None,
1100         'output_format':    'json',
1101         'requirements':     [Requirements.linux, Requirements.libaio],
1102     },
1103     {
1104         'test_id':          16,
1105         'test_class':       FioJobTest_t0015,
1106         'job':              't0016-d54ae22.fio',
1107         'success':          SUCCESS_DEFAULT,
1108         'pre_job':          None,
1109         'pre_success':      None,
1110         'output_format':    'json',
1111         'requirements':     [],
1112     },
1113     {
1114         'test_id':          17,
1115         'test_class':       FioJobTest_t0015,
1116         'job':              't0017.fio',
1117         'success':          SUCCESS_DEFAULT,
1118         'pre_job':          None,
1119         'pre_success':      None,
1120         'output_format':    'json',
1121         'requirements':     [Requirements.not_windows],
1122     },
1123     {
1124         'test_id':          18,
1125         'test_class':       FioJobTest,
1126         'job':              't0018.fio',
1127         'success':          SUCCESS_DEFAULT,
1128         'pre_job':          None,
1129         'pre_success':      None,
1130         'requirements':     [Requirements.linux, Requirements.io_uring],
1131     },
1132     {
1133         'test_id':          19,
1134         'test_class':       FioJobTest_t0019,
1135         'job':              't0019.fio',
1136         'success':          SUCCESS_DEFAULT,
1137         'pre_job':          None,
1138         'pre_success':      None,
1139         'requirements':     [],
1140     },
1141     {
1142         'test_id':          20,
1143         'test_class':       FioJobTest_t0020,
1144         'job':              't0020.fio',
1145         'success':          SUCCESS_DEFAULT,
1146         'pre_job':          None,
1147         'pre_success':      None,
1148         'requirements':     [],
1149     },
1150     {
1151         'test_id':          21,
1152         'test_class':       FioJobTest_t0020,
1153         'job':              't0021.fio',
1154         'success':          SUCCESS_DEFAULT,
1155         'pre_job':          None,
1156         'pre_success':      None,
1157         'requirements':     [],
1158     },
1159     {
1160         'test_id':          22,
1161         'test_class':       FioJobTest_t0022,
1162         'job':              't0022.fio',
1163         'success':          SUCCESS_DEFAULT,
1164         'pre_job':          None,
1165         'pre_success':      None,
1166         'requirements':     [],
1167     },
1168     {
1169         'test_id':          23,
1170         'test_class':       FioJobTest_t0023,
1171         'job':              't0023.fio',
1172         'success':          SUCCESS_DEFAULT,
1173         'pre_job':          None,
1174         'pre_success':      None,
1175         'requirements':     [],
1176     },
1177     {
1178         'test_id':          24,
1179         'test_class':       FioJobTest_t0024,
1180         'job':              't0024.fio',
1181         'success':          SUCCESS_DEFAULT,
1182         'pre_job':          None,
1183         'pre_success':      None,
1184         'requirements':     [],
1185     },
1186     {
1187         'test_id':          1000,
1188         'test_class':       FioExeTest,
1189         'exe':              't/axmap',
1190         'parameters':       None,
1191         'success':          SUCCESS_DEFAULT,
1192         'requirements':     [],
1193     },
1194     {
1195         'test_id':          1001,
1196         'test_class':       FioExeTest,
1197         'exe':              't/ieee754',
1198         'parameters':       None,
1199         'success':          SUCCESS_DEFAULT,
1200         'requirements':     [],
1201     },
1202     {
1203         'test_id':          1002,
1204         'test_class':       FioExeTest,
1205         'exe':              't/lfsr-test',
1206         'parameters':       ['0xFFFFFF', '0', '0', 'verify'],
1207         'success':          SUCCESS_STDERR,
1208         'requirements':     [],
1209     },
1210     {
1211         'test_id':          1003,
1212         'test_class':       FioExeTest,
1213         'exe':              't/readonly.py',
1214         'parameters':       ['-f', '{fio_path}'],
1215         'success':          SUCCESS_DEFAULT,
1216         'requirements':     [],
1217     },
1218     {
1219         'test_id':          1004,
1220         'test_class':       FioExeTest,
1221         'exe':              't/steadystate_tests.py',
1222         'parameters':       ['{fio_path}'],
1223         'success':          SUCCESS_DEFAULT,
1224         'requirements':     [],
1225     },
1226     {
1227         'test_id':          1005,
1228         'test_class':       FioExeTest,
1229         'exe':              't/stest',
1230         'parameters':       None,
1231         'success':          SUCCESS_STDERR,
1232         'requirements':     [],
1233     },
1234     {
1235         'test_id':          1006,
1236         'test_class':       FioExeTest,
1237         'exe':              't/strided.py',
1238         'parameters':       ['{fio_path}'],
1239         'success':          SUCCESS_DEFAULT,
1240         'requirements':     [],
1241     },
1242     {
1243         'test_id':          1007,
1244         'test_class':       FioExeTest,
1245         'exe':              't/zbd/run-tests-against-nullb',
1246         'parameters':       ['-s', '1'],
1247         'success':          SUCCESS_DEFAULT,
1248         'requirements':     [Requirements.linux, Requirements.zbd,
1249                              Requirements.root],
1250     },
1251     {
1252         'test_id':          1008,
1253         'test_class':       FioExeTest,
1254         'exe':              't/zbd/run-tests-against-nullb',
1255         'parameters':       ['-s', '2'],
1256         'success':          SUCCESS_DEFAULT,
1257         'requirements':     [Requirements.linux, Requirements.zbd,
1258                              Requirements.root, Requirements.zoned_nullb],
1259     },
1260     {
1261         'test_id':          1009,
1262         'test_class':       FioExeTest,
1263         'exe':              'unittests/unittest',
1264         'parameters':       None,
1265         'success':          SUCCESS_DEFAULT,
1266         'requirements':     [Requirements.unittests],
1267     },
1268     {
1269         'test_id':          1010,
1270         'test_class':       FioExeTest,
1271         'exe':              't/latency_percentiles.py',
1272         'parameters':       ['-f', '{fio_path}'],
1273         'success':          SUCCESS_DEFAULT,
1274         'requirements':     [],
1275     },
1276     {
1277         'test_id':          1011,
1278         'test_class':       FioExeTest,
1279         'exe':              't/jsonplus2csv_test.py',
1280         'parameters':       ['-f', '{fio_path}'],
1281         'success':          SUCCESS_DEFAULT,
1282         'requirements':     [],
1283     },
1284     {
1285         'test_id':          1012,
1286         'test_class':       FioExeTest,
1287         'exe':              't/log_compression.py',
1288         'parameters':       ['-f', '{fio_path}'],
1289         'success':          SUCCESS_DEFAULT,
1290         'requirements':     [],
1291     },
1292 ]
1293
1294
1295 def parse_args():
1296     """Parse command-line arguments."""
1297
1298     parser = argparse.ArgumentParser()
1299     parser.add_argument('-r', '--fio-root',
1300                         help='fio root path')
1301     parser.add_argument('-f', '--fio',
1302                         help='path to fio executable (e.g., ./fio)')
1303     parser.add_argument('-a', '--artifact-root',
1304                         help='artifact root directory')
1305     parser.add_argument('-s', '--skip', nargs='+', type=int,
1306                         help='list of test(s) to skip')
1307     parser.add_argument('-o', '--run-only', nargs='+', type=int,
1308                         help='list of test(s) to run, skipping all others')
1309     parser.add_argument('-d', '--debug', action='store_true',
1310                         help='provide debug output')
1311     parser.add_argument('-k', '--skip-req', action='store_true',
1312                         help='skip requirements checking')
1313     parser.add_argument('-p', '--pass-through', action='append',
1314                         help='pass-through an argument to an executable test')
1315     args = parser.parse_args()
1316
1317     return args
1318
1319
1320 def main():
1321     """Entry point."""
1322
1323     args = parse_args()
1324     if args.debug:
1325         logging.basicConfig(level=logging.DEBUG)
1326     else:
1327         logging.basicConfig(level=logging.INFO)
1328
1329     pass_through = {}
1330     if args.pass_through:
1331         for arg in args.pass_through:
1332             if not ':' in arg:
1333                 print("Invalid --pass-through argument '%s'" % arg)
1334                 print("Syntax for --pass-through is TESTNUMBER:ARGUMENT")
1335                 return
1336             split = arg.split(":", 1)
1337             pass_through[int(split[0])] = split[1]
1338         logging.debug("Pass-through arguments: %s", pass_through)
1339
1340     if args.fio_root:
1341         fio_root = args.fio_root
1342     else:
1343         fio_root = str(Path(__file__).absolute().parent.parent)
1344     print("fio root is %s" % fio_root)
1345
1346     if args.fio:
1347         fio_path = args.fio
1348     else:
1349         if platform.system() == "Windows":
1350             fio_exe = "fio.exe"
1351         else:
1352             fio_exe = "fio"
1353         fio_path = os.path.join(fio_root, fio_exe)
1354     print("fio path is %s" % fio_path)
1355     if not shutil.which(fio_path):
1356         print("Warning: fio executable not found")
1357
1358     artifact_root = args.artifact_root if args.artifact_root else \
1359         "fio-test-{0}".format(time.strftime("%Y%m%d-%H%M%S"))
1360     os.mkdir(artifact_root)
1361     print("Artifact directory is %s" % artifact_root)
1362
1363     if not args.skip_req:
1364         req = Requirements(fio_root)
1365
1366     passed = 0
1367     failed = 0
1368     skipped = 0
1369
1370     for config in TEST_LIST:
1371         if (args.skip and config['test_id'] in args.skip) or \
1372            (args.run_only and config['test_id'] not in args.run_only):
1373             skipped = skipped + 1
1374             print("Test {0} SKIPPED (User request)".format(config['test_id']))
1375             continue
1376
1377         if issubclass(config['test_class'], FioJobTest):
1378             if config['pre_job']:
1379                 fio_pre_job = os.path.join(fio_root, 't', 'jobs',
1380                                            config['pre_job'])
1381             else:
1382                 fio_pre_job = None
1383             if config['pre_success']:
1384                 fio_pre_success = config['pre_success']
1385             else:
1386                 fio_pre_success = None
1387             if 'output_format' in config:
1388                 output_format = config['output_format']
1389             else:
1390                 output_format = 'normal'
1391             test = config['test_class'](
1392                 fio_path,
1393                 os.path.join(fio_root, 't', 'jobs', config['job']),
1394                 config['success'],
1395                 fio_pre_job=fio_pre_job,
1396                 fio_pre_success=fio_pre_success,
1397                 output_format=output_format)
1398             desc = config['job']
1399         elif issubclass(config['test_class'], FioExeTest):
1400             exe_path = os.path.join(fio_root, config['exe'])
1401             if config['parameters']:
1402                 parameters = [p.format(fio_path=fio_path) for p in config['parameters']]
1403             else:
1404                 parameters = []
1405             if Path(exe_path).suffix == '.py' and platform.system() == "Windows":
1406                 parameters.insert(0, exe_path)
1407                 exe_path = "python.exe"
1408             if config['test_id'] in pass_through:
1409                 parameters += pass_through[config['test_id']].split()
1410             test = config['test_class'](exe_path, parameters,
1411                                         config['success'])
1412             desc = config['exe']
1413         else:
1414             print("Test {0} FAILED: unable to process test config".format(config['test_id']))
1415             failed = failed + 1
1416             continue
1417
1418         if not args.skip_req:
1419             reqs_met = True
1420             for req in config['requirements']:
1421                 reqs_met, reason = req()
1422                 logging.debug("Test %d: Requirement '%s' met? %s", config['test_id'], reason,
1423                               reqs_met)
1424                 if not reqs_met:
1425                     break
1426             if not reqs_met:
1427                 print("Test {0} SKIPPED ({1}) {2}".format(config['test_id'], reason, desc))
1428                 skipped = skipped + 1
1429                 continue
1430
1431         try:
1432             test.setup(artifact_root, config['test_id'])
1433             test.run()
1434             test.check_result()
1435         except KeyboardInterrupt:
1436             break
1437         except Exception as e:
1438             test.passed = False
1439             test.failure_reason += str(e)
1440             logging.debug("Test %d exception:\n%s\n", config['test_id'], traceback.format_exc())
1441         if test.passed:
1442             result = "PASSED"
1443             passed = passed + 1
1444         else:
1445             result = "FAILED: {0}".format(test.failure_reason)
1446             failed = failed + 1
1447             contents, _ = FioJobTest.get_file(test.stderr_file)
1448             logging.debug("Test %d: stderr:\n%s", config['test_id'], contents)
1449             contents, _ = FioJobTest.get_file(test.stdout_file)
1450             logging.debug("Test %d: stdout:\n%s", config['test_id'], contents)
1451         print("Test {0} {1} {2}".format(config['test_id'], result, desc))
1452
1453     print("{0} test(s) passed, {1} failed, {2} skipped".format(passed, failed, skipped))
1454
1455     sys.exit(failed)
1456
1457
1458 if __name__ == '__main__':
1459     main()