CoreValidation: Refactored matrix build script to use common implementations from buildutils.

CMSIS/CoreValidation/Tests/build.py

@@ -1,296 +0,0 @@
-#! python
-
-import sys
-import os
-from argparse import ArgumentParser
-from datetime import datetime
-from subprocess import call, Popen
-from pathlib import Path
-
-sys.path.append('buildutils') 
-
-from rtecmd import RteCmd 
-from uv4cmd import Uv4Cmd 
-from dscmd import DsCmd 
-from fvpcmd import FvpCmd 
-from iarcmd import IarCmd 
-from testresult import TestResult
-
-try:
-  rtebuildhome = os.path.join(os.path.abspath(Path.home()), ".rtebuild")
-  sys.path.append(rtebuildhome)
-  import buildenv
-except ModuleNotFoundError:
-  print("No custom buildenv.py found in "+rtebuildhome)
-  buildenv = None
-  pass
-
-DEVICE_CM0     = 'Cortex-M0'
-DEVICE_CM0PLUS = 'Cortex-M0plus'
-DEVICE_CM3     = 'Cortex-M3'
-DEVICE_CM4     = 'Cortex-M4'
-DEVICE_CM4FP   = 'Cortex-M4FP'
-DEVICE_CM7     = 'Cortex-M7'
-DEVICE_CM7SP   = 'Cortex-M7SP'
-DEVICE_CM7DP   = 'Cortex-M7DP'
-DEVICE_CM23    = 'Cortex-M23'
-DEVICE_CM33    = 'Cortex-M33'
-DEVICE_CM23NS  = 'Cortex-M23NS'
-DEVICE_CM33NS  = 'Cortex-M33NS'
-DEVICE_CM23S   = 'Cortex-M23S'
-DEVICE_CM33S   = 'Cortex-M33S'
-DEVICE_CA5     = 'Cortex-A5'
-DEVICE_CA7     = 'Cortex-A7'
-DEVICE_CA9     = 'Cortex-A9'
-DEVICE_CA5NEON = 'Cortex-A5neon'
-DEVICE_CA7NEON = 'Cortex-A7neon'
-DEVICE_CA9NEON = 'Cortex-A9neon'
-
-CC_AC6    = 'AC6'
-CC_AC6LTM = 'AC6LTM'
-CC_AC5    = 'AC5'
-CC_GCC    = 'GCC'
-CC_IAR    = 'IAR'
-
-TARGET_FVP = 'FVP'
-
-ADEVICES = {
-    DEVICE_CM0     : 'CM0',
-    DEVICE_CM0PLUS : 'CM0plus',
-    DEVICE_CM3     : 'CM3',
-    DEVICE_CM4     : 'CM4',
-    DEVICE_CM4FP   : 'CM4FP',
-    DEVICE_CM7     : 'CM7',
-    DEVICE_CM7SP   : 'CM7SP',
-    DEVICE_CM7DP   : 'CM7DP',
-    DEVICE_CM23    : 'CM23',
-    DEVICE_CM33    : 'CM33',
-    DEVICE_CM23S   : 'CM23S',
-    DEVICE_CM33S   : 'CM33S',
-    DEVICE_CM33NS  : 'CM33NS',
-    DEVICE_CM23NS  : 'CM23NS',
-    DEVICE_CA5     : 'CA5',
-    DEVICE_CA7     : 'CA7',
-    DEVICE_CA9     : 'CA9',
-    DEVICE_CA5NEON : 'CA5neon',
-    DEVICE_CA7NEON : 'CA7neon',
-    DEVICE_CA9NEON : 'CA9neon'
-  }
-
-DEVICES = [ DEVICE_CM0, DEVICE_CM0PLUS, DEVICE_CM3, DEVICE_CM4, DEVICE_CM4FP, DEVICE_CM7, DEVICE_CM7SP, DEVICE_CM7DP, DEVICE_CM23, DEVICE_CM33, DEVICE_CM23NS, DEVICE_CM33NS, DEVICE_CM23S, DEVICE_CM33S, DEVICE_CA5, DEVICE_CA7, DEVICE_CA9, DEVICE_CA5NEON, DEVICE_CA7NEON, DEVICE_CA9NEON ]
-COMPILERS = [ CC_AC5, CC_AC6, CC_AC6LTM, CC_GCC, CC_IAR ]
-TARGETS = [ TARGET_FVP ]
-
-SKIP = [ 
-    [ DEVICE_CM23,    CC_AC5,    None ],
-    [ DEVICE_CM33,    CC_AC5,    None ],
-    [ DEVICE_CM23NS,  CC_AC5,    None ],
-    [ DEVICE_CM33NS,  CC_AC5,    None ],
-    [ DEVICE_CM23S,   CC_AC5,    None ],
-    [ DEVICE_CM33S,   CC_AC5,    None ],
-    [ DEVICE_CM0,     CC_AC6LTM, None ],
-    [ DEVICE_CM0PLUS, CC_AC6LTM, None ],
-    [ DEVICE_CM23,    CC_AC6LTM, None ],
-    [ DEVICE_CM33,    CC_AC6LTM, None ],
-    [ DEVICE_CM23NS,  CC_AC6LTM, None ],
-    [ DEVICE_CM33NS,  CC_AC6LTM, None ],
-    [ DEVICE_CM23S,   CC_AC6LTM, None ],
-    [ DEVICE_CM33S,   CC_AC6LTM, None ],
-  ]
-  
-FVP_MODELS = { 
-    DEVICE_CM0      : { 'cmd': "FVP_MPS2_Cortex-M0_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM0_config.txt" } },
-    DEVICE_CM0PLUS  : { 'cmd': "FVP_MPS2_Cortex-M0plus_MDK.exe",  'args': { 'limit': "50000000", 'config': "ARMCM0plus_config.txt" } },
-    DEVICE_CM3      : { 'cmd': "FVP_MPS2_Cortex-M3_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM3_config.txt" } },
-    DEVICE_CM4      : { 'cmd': "FVP_MPS2_Cortex-M4_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM4_config.txt" } },
-    DEVICE_CM4FP    : { 'cmd': "FVP_MPS2_Cortex-M4_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM4FP_config.txt" } },
-    DEVICE_CM7      : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM7_config.txt" } },
-    DEVICE_CM7SP    : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM7SP_config.txt" } },
-    DEVICE_CM7DP    : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "50000000", 'config': "ARMCM7DP_config.txt" } },
-    DEVICE_CM23     : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM23_config.txt",           'target': "cpu0" } },
-    DEVICE_CM33     : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM33_config.txt",           'target': "cpu0" } },
-    DEVICE_CM23NS   : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM23_TZ_config.txt",        'target': "cpu0" } },
-    DEVICE_CM33NS   : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM33_DSP_FP_TZ_config.txt", 'target': "cpu0" } },
-    DEVICE_CM23S    : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM23_TZ_config.txt",        'target': "cpu0" } },
-    DEVICE_CM33S    : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "50000000", 'config': "ARMCM33_DSP_FP_TZ_config.txt", 'target': "cpu0" } },
-    DEVICE_CA5      : { 'cmd': "fvp_ve_cortex-a5x1.exe",          'args': { 'limit': "70000000", 'config': "ARMCA5_config.txt" } },
-    DEVICE_CA7      : { 'cmd': "fvp_ve_cortex-a7x1.exe",          'args': { 'limit': "170000000", 'config': "ARMCA7_config.txt" } },
-    DEVICE_CA9      : { 'cmd': "fvp_ve_cortex-a9x1.exe",          'args': { 'limit': "70000000", 'config': "ARMCA9_config.txt" } },
-    DEVICE_CA5NEON  : { 'cmd': "fvp_ve_cortex-a5x1.exe",          'args': { 'limit': "70000000", 'config': "ARMCA5neon_config.txt" } },
-    DEVICE_CA7NEON  : { 'cmd': "fvp_ve_cortex-a7x1.exe",          'args': { 'limit': "170000000", 'config': "ARMCA7neon_config.txt" } },
-    DEVICE_CA9NEON  : { 'cmd': "fvp_ve_cortex-a9x1.exe",          'args': { 'limit': "70000000", 'config': "ARMCA9neon_config.txt" } }
-  }
-
-def isSkipped(dev, cc, target):
-  for skip in SKIP:
-    skipDev = (skip[0] == None or skip[0] == dev)
-    skipCc = (skip[1] == None or skip[1] == cc)
-    skipTarget = (skip[2] == None or skip[2] == target)
-    if skipDev and skipCc and skipTarget:
-      return True
-  return False
-  
-def testProject(dev, cc, target):
-  rtebuild = "{dev}/{cc}/default.rtebuild".format(dev = dev, cc = cc, target=target)
-  if os.path.exists(rtebuild):
-    return [
-        rtebuild,
-        "{dev}/{cc}/build/{target}/{target}.elf".format(dev = dev, cc = cc, target=target)
-      ]
-  elif (cc == CC_AC5) or (cc == CC_AC6):
-    return [
-        "{dev}/{cc}/CMSIS_CV.uvprojx".format(dev = dev, cc = cc),
-        "{dev}/{cc}/Objects/CMSIS_CV.axf".format(dev = dev, cc = cc)
-      ]
-  elif (cc == CC_AC6LTM):
-    return [
-        "{dev}/{cc}/CMSIS_CV.uvprojx".format(dev = dev, cc = CC_AC6),
-        "{dev}/{cc}/Objects/CMSIS_CV.axf".format(dev = dev, cc = CC_AC6)
-      ]
-  elif (cc == CC_GCC):
-    return [
-        "{dev}/{cc}/CMSIS_CV.uvprojx".format(dev = dev, cc = cc),
-        "{dev}/{cc}/Objects/CMSIS_CV.elf".format(dev = dev, cc = cc)
-      ]
-  elif (cc == CC_IAR):
-    return [
-        "{dev}/{cc}/CMSIS_CV.ewp".format(dev = dev, cc = cc),
-        "{dev}/{cc}/{target}/Exe/CMSIS_CV.out".format(dev = dev, cc = cc, target = target)
-      ]
-  raise "Unknown compiler!"
-
-def bootloaderProject(dev, cc, target):
-  rtebuild = "{dev}/{cc}/Bootloader/default.rtebuild".format(dev = dev, cc = cc, target=target)
-  if os.path.exists(rtebuild):
-    return [
-        rtebuild,
-        "{dev}/{cc}/Bootloader/build/{target}/{target}.elf".format(dev = dev, cc = cc, target=target)
-      ]
-  elif (cc == CC_AC5) or (cc == CC_AC6):
-    return [
-        "{dev}/{cc}/Bootloader/Bootloader.uvprojx".format(dev = dev, cc = cc),
-        "{dev}/{cc}/Bootloader/Objects/Bootloader.axf".format(dev = dev, cc = cc)
-      ] 
-  elif (cc == CC_AC6LTM):
-    return [
-        "{dev}/{cc}/Bootloader/Bootloader.uvprojx".format(dev = dev, cc = CC_AC6),
-        "{dev}/{cc}/Bootloader/Objects/Bootloader.axf".format(dev = dev, cc = CC_AC6)
-      ] 
-  elif (cc == CC_GCC):
-    return [
-        "{dev}/{cc}/Bootloader/Bootloader.uvprojx".format(dev = dev, cc = cc),
-        "{dev}/{cc}/Bootloader/Objects/Bootloader.elf".format(dev = dev, cc = cc)
-      ] 
-  elif (cc == CC_IAR):
-    return [
-        "{dev}/{cc}/Bootloader/Bootloader.ewp".format(dev = dev, cc = cc),
-        "{dev}/{cc}/Bootloader/{target}/Exe/Bootloader.out".format(dev = dev, cc = cc, target = target)
-      ]
-  raise "Unknown compiler!"
-  
-def buildStep(dev, cc, target, project, env=os.environ):
-  STEP_TYPES = {
-    ".uvprojx"  : Uv4Cmd,
-    ".ewp"      : IarCmd,
-    ".rtebuild" : RteCmd
-  }
-  
-  projectfile, projectext = os.path.splitext(project)
-  
-  if not projectext in STEP_TYPES:
-    raise "Unknown project type '"+projectext+"'!"
-    
-  return STEP_TYPES[projectext](project, target, env)
-  
-def prepare(steps, args):
-  for dev in args.devices:
-    for cc in args.compilers:
-      for target in args.targets:
-        if not isSkipped(dev, cc, target):
-          config = "{dev} ({cc}, {target})".format(dev = dev, cc = cc, target = target)
-          prefix = "{dev}_{cc}_{target}".format(dev = dev, cc = cc, target = target)
-          
-          env = os.environ
-          if hasattr(buildenv, "env_"+cc):
-            env = getattr(buildenv, "env_"+cc)()
-
-          rv = testProject(dev, cc, target)
-          build = [ buildStep(dev, cc, target, rv[0], env=env) ]
-          binary = [ rv[1] ]
-          
-          bl = bootloaderProject(dev, cc, target)
-          if os.path.isfile(bl[0]):
-            build = [ buildStep(dev, cc, target, bl[0], env=env) ] + build
-            binary = [ bl[1] ] + binary
-
-          if target == TARGET_FVP:
-            test = FvpCmd(FVP_MODELS[dev]['cmd'], binary, **FVP_MODELS[dev]['args'])
-          steps += [ { 'name': config, 'prefix': prefix, 'build': build, 'test': test } ]
-
-def execute(steps, args):
-  for step in steps:
-    print(step['name'])
-    if step['build'] and not args.execute_only:
-      for b in step['build']:
-        b.run()
-    else:
-      print("Skipping build")
-      # step['build'].skip()
-      
-    if step['test'] and not args.build_only:
-      step['test'].run()
-      step['result'] = TestResult(step['test'].getOutput())
-      step['result'].saveXml("result_{0}_{1}.xml".format(step['prefix'], datetime.now().strftime("%Y%m%d%H%M%S")))
-    else:
-      print("Skipping test")
-      step['test'].skip()
-      
-def printSummary(steps):
-  print("")
-  print("Test Summary")
-  print("============")
-  print()
-  print("Test run                       Total Exec  Pass  Fail  ")
-  print("-------------------------------------------------------")
-  for step in steps:
-    try:
-      print("{0:30} {1:>4}  {2:>4}  {3:>4}  {4:>4}".format(step['name'], *step['result'].getSummary()))
-    except:
-      print("{0:30} ------ NO RESULTS ------".format(step['name']))
-
-def main(argv):
-  parser = ArgumentParser()
-  parser.add_argument('--genconfig', action='store_true')
-  parser.add_argument('-b', '--build-only', action='store_true')
-  parser.add_argument('-e', '--execute-only', action='store_true')
-  parser.add_argument('-d', '--devices', nargs='*', choices=(DEVICES+list(ADEVICES.values())), default=DEVICES, help = 'Devices to be considered.')
-  parser.add_argument('-c', '--compilers', nargs='*', choices=COMPILERS, default=COMPILERS, help = 'Compilers to be considered.')
-  parser.add_argument('-t', '--targets', nargs='*', choices=TARGETS, default=TARGETS, help = 'Targets to be considered.')
-  args = parser.parse_args()
-  
-  devices = set()
-  for d in args.devices:
-    if d in ADEVICES.values():
-      d = list(ADEVICES.keys())[list(ADEVICES.values()).index(d)]
-    devices.add(d)
-  
-  args.devices = list(devices)
-    
-  if args.genconfig:
-    for dev in args.devices:
-      model = FVP_MODELS[dev]
-      cmd = [ model['cmd'], '-l', '-o', model['args']['config'] ]
-      print(" ".join(cmd))
-      call(cmd)
-    return 1
-    
-  steps = []
-
-  prepare(steps, args)
-  
-  execute(steps, args)
-  
-  printSummary(steps)
-  
-if __name__ == "__main__":
-  main(sys.argv[1:])

CMSIS/CoreValidation/Tests/builder.py

@@ -0,0 +1,144 @@
+#! python
+
+import os
+import shutil
+import sys
+
+from buildutils.builder import Device, Compiler, Axis, Step, BuildStep, RunModelStep, Builder, Filter
+
+TARGET_FVP = 'FVP'
+  
+FVP_MODELS = { 
+    Device.CM0      : { 'cmd': "FVP_MPS2_Cortex-M0_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM0_config.txt" } },
+    Device.CM0PLUS  : { 'cmd': "FVP_MPS2_Cortex-M0plus_MDK.exe",  'args': { 'limit': "100000000", 'config': "config/ARMCM0plus_config.txt" } },
+    Device.CM3      : { 'cmd': "FVP_MPS2_Cortex-M3_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM3_config.txt" } },
+    Device.CM4      : { 'cmd': "FVP_MPS2_Cortex-M4_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM4_config.txt" } },
+    Device.CM4FP    : { 'cmd': "FVP_MPS2_Cortex-M4_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM4FP_config.txt" } },
+    Device.CM7      : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM7_config.txt" } },
+    Device.CM7SP    : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM7SP_config.txt" } },
+    Device.CM7DP    : { 'cmd': "FVP_MPS2_Cortex-M7_MDK.exe",      'args': { 'limit': "100000000", 'config': "config/ARMCM7DP_config.txt" } },
+    Device.CM23     : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM23_config.txt",           'target': "cpu0" } },
+    Device.CM33     : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM33_config.txt",           'target': "cpu0" } },
+    Device.CM23NS   : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM23_TZ_config.txt",        'target': "cpu0" } },
+    Device.CM33NS   : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM33_DSP_FP_TZ_config.txt", 'target': "cpu0" } },
+    Device.CM23S    : { 'cmd': "FVP_MPS2_Cortex-M23_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM23_TZ_config.txt",        'target': "cpu0" } },
+    Device.CM33S    : { 'cmd': "FVP_MPS2_Cortex-M33_MDK.exe",     'args': { 'limit': "100000000", 'config': "config/ARMCM33_DSP_FP_TZ_config.txt", 'target': "cpu0" } },
+    Device.CA5      : { 'cmd': "fvp_ve_cortex-a5x1.exe",          'args': { 'limit': "100000000", 'config': "config/ARMCA5_config.txt" } },
+    Device.CA7      : { 'cmd': "fvp_ve_cortex-a7x1.exe",          'args': { 'limit': "170000000", 'config': "config/ARMCA7_config.txt" } },
+    Device.CA9      : { 'cmd': "fvp_ve_cortex-a9x1.exe",          'args': { 'limit': "100000000", 'config': "config/ARMCA9_config.txt" } },
+    Device.CA5NEON  : { 'cmd': "fvp_ve_cortex-a5x1.exe",          'args': { 'limit': "100000000", 'config': "config/ARMCA5neon_config.txt" } },
+    Device.CA7NEON  : { 'cmd': "fvp_ve_cortex-a7x1.exe",          'args': { 'limit': "170000000", 'config': "config/ARMCA7neon_config.txt" } },
+    Device.CA9NEON  : { 'cmd': "fvp_ve_cortex-a9x1.exe",          'args': { 'limit': "100000000", 'config': "config/ARMCA9neon_config.txt" } }
+  }
+
+def format(str, dev, cc, target = "FVP"):
+  return str.format(dev = dev.value[0], cc = cc.value, target = target)
+  
+def testProject(dev, cc, target):
+  rtebuild = format("{dev}/{cc}/default.rtebuild", dev = dev, cc = cc, target=target)
+  if os.path.exists(rtebuild):
+    return [
+        rtebuild,
+        format("{dev}/{cc}/build/{target}/{target}.elf", dev = dev, cc = cc, target=target)
+      ]
+  elif (cc == Compiler.AC5) or (cc == Compiler.AC6):
+    return [
+        format("{dev}/{cc}/CMSIS_CV.uvprojx", dev = dev, cc = cc),
+        format("{dev}/{cc}/Objects/CMSIS_CV.axf", dev = dev, cc = cc)
+      ]
+  elif (cc == Compiler.AC6LTM):
+    return [
+        format("{dev}/{cc}/CMSIS_CV.uvprojx", dev = dev, cc = Compiler.AC6),
+        format("{dev}/{cc}/Objects/CMSIS_CV.axf", dev = dev, cc = Compiler.AC6)
+      ]
+  elif (cc == Compiler.GCC):
+    return [
+        format("{dev}/{cc}/CMSIS_CV.uvprojx", dev = dev, cc = cc),
+        format("{dev}/{cc}/Objects/CMSIS_CV.elf", dev = dev, cc = cc)
+      ]
+  elif (cc == Compiler.IAR):
+    return [
+        format("{dev}/{cc}/CMSIS_CV.ewp", dev = dev, cc = cc),
+        format("{dev}/{cc}/{target}/Exe/CMSIS_CV.out", dev = dev, cc = cc, target = target)
+      ]
+  raise "Unknown compiler!"
+
+def bootloaderProject(dev, cc, target):
+  rtebuild = format("{dev}/{cc}/Bootloader/default.rtebuild", dev = dev, cc = cc, target=target)
+  if os.path.exists(rtebuild):
+    return [
+        rtebuild,
+        format("{dev}/{cc}/Bootloader/build/{target}/{target}.elf", dev = dev, cc = cc, target=target)
+      ]
+  elif (cc == Compiler.AC5) or (cc == Compiler.AC6):
+    return [
+        format("{dev}/{cc}/Bootloader/Bootloader.uvprojx", dev = dev, cc = cc),
+        format("{dev}/{cc}/Bootloader/Objects/Bootloader.axf", dev = dev, cc = cc)
+      ] 
+  elif (cc == Compiler.AC6LTM):
+    return [
+        format("{dev}/{cc}/Bootloader/Bootloader.uvprojx", dev = dev, cc = Compiler.AC6),
+        format("{dev}/{cc}/Bootloader/Objects/Bootloader.axf", dev = dev, cc = Compiler.AC6)
+      ] 
+  elif (cc == Compiler.GCC):
+    return [
+        format("{dev}/{cc}/Bootloader/Bootloader.uvprojx", dev = dev, cc = cc),
+        format("{dev}/{cc}/Bootloader/Objects/Bootloader.elf", dev = dev, cc = cc)
+      ] 
+  elif (cc == Compiler.IAR):
+    return [
+        format("{dev}/{cc}/Bootloader/Bootloader.ewp", dev = dev, cc = cc),
+        format("{dev}/{cc}/Bootloader/{target}/Exe/Bootloader.out", dev = dev, cc = cc, target = target)
+      ]
+  raise "Unknown compiler!"
+
+def projects(step, config):
+  dev = config['device']
+  cc = config['compiler']
+  target = config['target']
+  
+  projects = []
+  blPrj = bootloaderProject(dev, cc, target)
+  if os.path.exists(blPrj[0]):
+    projects += [ blPrj[0] ]
+  
+  projects += [ testProject(dev, cc, target)[0] ]
+  
+  return projects
+  
+def images(step, config):
+  dev = config['device']
+  cc = config['compiler']
+  target = config['target']
+  
+  images = []
+  blPrj = bootloaderProject(dev, cc, target)
+  if os.path.exists(blPrj[1]):
+    images += [ blPrj[1] ]
+  
+  images += [ testProject(dev, cc, target)[1] ]
+  
+  return images
+  
+def create():
+  deviceAxis = Axis("device", abbrev="d", values=Device, desc="Device(s) to be considered.")
+  compilerAxis = Axis("compiler", abbrev="c", values=Compiler, desc="Compiler(s) to be considered.")
+  targetAxis = Axis("target", abbrev="t", values=[ TARGET_FVP ], desc="Target(s) to be considered.")
+  
+  buildStep = BuildStep("build", abbrev="b", desc="Build the selected configurations.")
+  buildStep.projects = projects 
+  buildStep.target = lambda step, config: config['target']
+  
+  runStep = RunModelStep("run", abbrev="r", desc="Run the selected configurations.")
+  runStep.images = images
+  runStep.model = lambda step, config: FVP_MODELS[config['device']]
+  
+  filterAC5 = Filter().addAxis(compilerAxis, Compiler.AC5).addAxis(deviceAxis, "CM[23]3*")
+  filterAC6LTM = Filter().addAxis(compilerAxis, Compiler.AC6LTM).addAxis(deviceAxis, "CM[23]3*").addAxis(deviceAxis, "CM0*")
+
+  builder = Builder()
+  builder.addAxis([ compilerAxis, deviceAxis, targetAxis ])
+  builder.addStep([ buildStep, runStep ])
+  builder.addFilter([ filterAC5, filterAC6LTM ])
+
+  return builder

CMSIS/CoreValidation/Tests/buildutils/buildcmd.py

@@ -1,56 +0,0 @@
-#! python
-
-import os
-import shutil
-from subprocess import Popen
-from tempfile import TemporaryFile
-
-class BuildCmd:
-  def __init__(self, env=os.environ):
-    self._result = -1
-    self._output = TemporaryFile(mode="r+")
-    self._env = env
-    
-  def getCommand(self):
-    raise NotImplementedError
-    
-  def getArguments(self):
-    return []
-    
-  def needsShell(self):
-    return False
-    
-  def getOutput(self):
-    return self._output
-
-  def getLog(self):
-    return None
-    
-  def isSuccess(self):
-    return self._output == 0
-
-  def run(self):  
-    cmd = shutil.which(self.getCommand(), path=self._env['PATH'])
-    if not cmd:
-      raise FileNotFoundError(self.getCommand() + " in PATH='" + self._env['PATH']+"'")
-    cmd = [ os.path.normpath(cmd) ] + self.getArguments()
-    print("Running: " + ' '.join(cmd))
-    try:
-      with Popen(cmd, stdout = self._output, stderr = self._output, shell=self.needsShell(), env=self._env) as proc:
-        self._result = proc.wait()
-    except:
-      print("Fatal error!")
-    self._output.seek(0)
-    print(self._output.read())
-    
-    logfile = self.getLog()
-    if logfile != None:
-      print(logfile.read())
-      
-    print("Command returned: {0}".format(self._result))
-      
-    return self._result
-    
-  def skip(self):
-    self._result = 0
-    

CMSIS/CoreValidation/Tests/buildutils/dircmd.py

@@ -1,13 +0,0 @@
-#! python
-
-from buildcmd import BuildCmd
-
-class DirCmd(BuildCmd):
-
-  def __init__(self):
-    BuildCmd.__init__(self)
-    
-  def getCommand(self):
-    return "dir"
-
-    

CMSIS/CoreValidation/Tests/buildutils/dscmd.py

@@ -1,36 +0,0 @@
-#! python
-
-import os
-from buildcmd import BuildCmd
-from datetime import datetime
-import mmap
-
-class DsCmd(BuildCmd):
-
-  def __init__(self, project, config):
-    BuildCmd.__init__(self)
-    self._project = project
-    self._config = config
-    
-    workspace = os.getenv('WORKSPACE')
-    if workspace:
-      self._workspace = os.path.join(workspace, "eclipse")
-    else:
-      self._workspace = os.getenv('DSMDK_WORKSPACE')
-    if not self._workspace:
-      raise RuntimeError("No DS-MDK workspace found, set either DSMDK_WORKSPACE or WORKSPACE in environment!")
-
-  def getCommand(self):
-    return "eclipsec.exe"
-    
-  def getArguments(self):
-    return [
-        "-nosplash",
-        "-application", "org.eclipse.cdt.managedbuilder.core.headlessbuild",
-        "-data", self._workspace,
-        "-import", os.path.dirname(os.path.abspath(self._project)),
-        "-cleanBuild", self._config
-      ]
-  
-  def isSuccess(self):
-    return self._result == 0

CMSIS/CoreValidation/Tests/buildutils/fvpcmd.py

@@ -1,26 +0,0 @@
-#! python
-
-from buildcmd import BuildCmd
-
-class FvpCmd(BuildCmd):
-
-  def __init__(self, model, app, **args):
-    BuildCmd.__init__(self)
-    self._model = model
-    self._app = app
-    self._args = args
-    
-  def getCommand(self):
-    return self._model
-    
-  def getArguments(self):
-    args = []
-    if 'limit' in self._args:  args += [ "--cyclelimit", self._args['limit'] ] 
-    if 'config' in self._args: args += [ "-f", self._args['config'] ]
-    if 'target' in self._args:
-      for a in self._app:
-        args += [ "-a", "{0}={1}".format(self._args['target'], a ) ]
-    else:
-      args += [ self._app[0] ]
-    return args
-    

CMSIS/CoreValidation/Tests/buildutils/iarcmd.py

@@ -1,30 +0,0 @@
-#! python
-
-import os
-from buildcmd import BuildCmd
-from datetime import datetime
-import mmap
-
-class IarCmd(BuildCmd):
-
-  def __init__(self, project, config, env=os.environ):
-    BuildCmd.__init__(self, env=env)
-    self._project = project
-    self._config = config
-    self._log = "iar_{0}.log".format(datetime.now().strftime("%Y%m%d%H%M%S"))
-    self._env = env
-    
-  def getCommand(self):
-    return "iarbuild.exe"
-    
-  def getArguments(self):
-    return [ self._project, "-build", self._config ]
-  
-  def isSuccess(self):
-    return self._result <= 1
-
-  def getLog(self):
-    try:
-      return open(self._log, "r")
-    except:
-      return None

CMSIS/CoreValidation/Tests/buildutils/rtecmd.py

@@ -1,33 +0,0 @@
-#! python
-
-import os
-import shutil
-from buildcmd import BuildCmd
-from datetime import datetime
-import mmap
-
-class RteCmd(BuildCmd):
-
-  def __init__(self, project, config, env=os.environ, subcmd = "build"):
-    BuildCmd.__init__(self, env=env)
-    self._project = project
-    self._config = config
-    self._subcmd = subcmd
-    self._rtebuild = shutil.which("rtebuild.py")
-    if not self._rtebuild:
-      raise FileNotFoundError("rtebuild.py")
-      
-  def getCommand(self):
-    return "python.exe"
-    
-  def getArguments(self):
-    return [ os.path.normpath(self._rtebuild), "-c", os.path.abspath(self._project), "-t", self._config, self._subcmd ]
-
-  def needsShell(self):
-    return True
-    
-  def isSuccess(self):
-    return self._result == 0
-
-  def getLog(self):
-      return None

CMSIS/CoreValidation/Tests/buildutils/testresult.py

@@ -1,51 +0,0 @@
-#! python
-
-import shutil
-from io import StringIO
-from xml.etree import ElementTree
-
-class TestResult:
-
-  def _extractXml(self, log, xml):
-    dump = False
-    log.seek(0)
-    for line in log:
-      if dump:
-        xml.write(line)
-        if line.strip() == '</report>':
-          dump = False
-      else:
-        if line.strip() == '<?xml version="1.0"?>':
-          dump = True
-          xml.write(line)
-
-  def __init__(self, log):
-    self._xml = StringIO()
-    self._extractXml(log, self._xml)
-    self._xml.seek(0)
-  
-    try:
-      report = ElementTree.parse(self._xml).getroot()
-      summary = report[0].findall('summary')[0]
-      self._tests = summary.find('tcnt').text
-      self._executed = summary.find('exec').text
-      self._passed = summary.find('pass').text
-      self._failed = summary.find('fail').text
-      self._avail = True
-    except ElementTree.ParseError as e:
-      self._avail = False
-      self._except = e
-          
-  def saveXml(self, filename):
-    with open(filename, "w") as file:
-      self._xml.seek(0)
-      shutil.copyfileobj(self._xml, file)
-    
-  def isAvailable(self):
-    return self._avail
-    
-  def getSummary(self):
-    if self._avail:
-      return self._tests, self._executed, self._passed, self._failed
-    else:
-      raise self._except

CMSIS/CoreValidation/Tests/buildutils/uv4cmd.py

@@ -1,22 +0,0 @@
-#! python
-
-import os
-import shutil
-from buildcmd import BuildCmd
-from datetime import datetime
-
-class Uv4Cmd(BuildCmd):
-
-  def __init__(self, project, config, env=os.environ):
-    BuildCmd.__init__(self, env=env)
-    self._project = project
-    self._config = config
-
-  def getCommand(self):
-    return "uVision.com"
-    
-  def getArguments(self):
-    return [ "-t", self._config, "-r", self._project, "-j0" ]
-  
-  def isSuccess(self):
-    return self._result <= 1

CMSIS/CoreValidation/Tests/lint.py

@@ -1,28 +0,0 @@
-import sys
-import os.path
-from argparse import ArgumentParser
-
-sys.path.append('buildutils') 
-
-from rtecmd import RteCmd 
-
-def main(argv):
-  parser = ArgumentParser()
-  parser.add_argument('-d', '--device', required=True, help = 'Device to be considered.')
-  parser.add_argument('-c', '--compiler', required=True, help = 'Compiler to be considered.')
-  parser.add_argument('-t', '--target', nargs='?', default="default", help = 'Target to be considered.')
-  args = parser.parse_args()
-  
-  rtebuild = os.path.join(args.device, args.compiler, "default.rtebuild")
-  
-  if not os.path.isfile(rtebuild):
-    raise IOError("rtebuild project not available:'"+rtebuild+"'")
-    
-  cmd = RteCmd(rtebuild, args.target, "lint")
-  cmd.run()
-  
-if __name__ == "__main__":
-  try:
-    main(sys.argv[1:])
-  except Exception as e:
-    print(e)

CMSIS/CoreValidation/Tests/update.py

@@ -1,26 +0,0 @@
-
-import sys
-import os
-import hashlib
-import shutil
-from glob import iglob
-from argparse import ArgumentParser
-
-def main():
-  parser = ArgumentParser()
-  parser.add_argument("-n", "--dry-run", action="store_true")
-  parser.add_argument("old")
-  parser.add_argument("new", nargs="+")
-  args = parser.parse_args()
-  
-  for old in iglob(args.old, recursive=True):
-    for new in args.new:
-      dest = os.path.join(os.path.dirname(old), os.path.basename(new))
-      print("Updating {0}".format(dest))
-      if not args.dry_run:
-        if os.path.exists(dest):
-          os.remove(dest)
-        shutil.copy2(new, dest)
-
-if __name__ == "__main__":
-  main()