Jenkinsfile

pipeline {
  agent none
  parameters {
    booleanParam(name: 'OLDLIBS', defaultValue: false, description: 'Also test some outdated libraries')

    booleanParam(name: 'v1_25', defaultValue: false, description: 'maintenance/v1.25 branch (ryzen-5950x-1)')
    booleanParam(name: 'v1_26', defaultValue: false, description: 'maintenance/v1.26 branch (ryzen-5950x-1)')
    booleanParam(name: 'master', defaultValue: false, description: 'master branch (ryzen-5950x-1)')

    booleanParam(name: 'fmi_v1_25', defaultValue: false, description: 'maintenance/v1.25 branch with FMI (ryzen-5950x-2)')
    booleanParam(name: 'fmi_v1_26', defaultValue: false, description: 'maintenance/v1.26 branch with FMI (ryzen-5950x-2)')
    booleanParam(name: 'fmi_master', defaultValue: false, description: 'master branch with FMI running OMSimulator (ryzen-5950x-2)')

    booleanParam(name: 'cs_fmu_cvode_v1_25', defaultValue: false, description: 'maintenance/v1.25 branch with CVODE CS FMUs running OMSimulator (ryzen-5950x-2)')
    booleanParam(name: 'cs_fmu_cvode_v1_26', defaultValue: false, description: 'maintenance/v1.26 branch with CVODE CS FMUs running OMSimulator (ryzen-5950x-2)')
    booleanParam(name: 'cs_fmu_cvode_master', defaultValue: false, description: 'master branch with CVODE CS FMUs running OMSimulator (ryzen-5950x-2)')

    booleanParam(name: 'fmpy_fmi_v1_25', defaultValue: false, description: 'maintenance/v1.25 branch with FMI (ryzen-5950x-2)')
    booleanParam(name: 'fmpy_fmi_v1_26', defaultValue: false, description: 'maintenance/v1.26 branch with FMI (ryzen-5950x-2)')
    booleanParam(name: 'fmpy_fmi_master', defaultValue: false, description: 'master branch with FMI running FMPy (ryzen-5950x-2)')

    booleanParam(name: 'newInst_daeMode', defaultValue: false, description: 'master branch, --daeMode with -d=newInst (ryzen-5950x-2)')
    booleanParam(name: 'newInst_newBackend', defaultValue: false, description: 'master branch, -d=newInst --newBackend, (ryzen-5950x-1)')
    booleanParam(name: 'newBackend_daeMode', defaultValue: false, description: 'master branch, --newBackend --daeMode with -d=newInst (ryzen-5950x-2). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'oldInst', defaultValue: false, description: 'master branch, with -d=nonewInst (ryzen-5950x-2)')

    booleanParam(name: 'cpp_v1_25', defaultValue: false, description: 'maintenance/v1.25 branch, with --simCodeTarget=Cpp (ryzen-5950x-2).')
    booleanParam(name: 'cpp_v1_26', defaultValue: false, description: 'maintenance/v1.26 branch, with --simCodeTarget=Cpp (ryzen-5950x-2).')
    booleanParam(name: 'cpp', defaultValue: false, description: 'master branch, with --simCodeTarget=Cpp (ryzen-5950x-2).')
    booleanParam(name: 'report_ryzen_5950x_1', defaultValue: false, description: 'Generate a report for ryzen-5950x-1 without running the tests')
    booleanParam(name: 'report_ryzen_5950x_2', defaultValue: false, description: 'Generate a report for ryzen-5950x-2 without running the tests')

    booleanParam(name: 'conversion_script', defaultValue: false, description: 'master branch with conversion script from MSL 3 to 4 (ryzen-5950x-1). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'cvode', defaultValue: false, description: 'master branch, with -d=newInst and -s cvode (ryzen-5950x-2). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'gbode', defaultValue: false, description: 'master branch, with -d=newInst and -s gbode (ryzen-5950x-2). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'ida', defaultValue: false, description: 'master branch, with -d=newInst and -s ida (ryzen-5950x-2). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'generateSymbolicJacobian', defaultValue: false, description: 'master branch, with --generateSymbolicJacobian (ryzen-5950x-1). This is an experimental job that does not run on a fixed schedule.')
    booleanParam(name: 'heavy_tests', defaultValue: false, description: 'master branch, runs one test at a time. That is, no parallel launching of tests. omc will use multiple threads for each test (-n=1 is not set unlike the other regression tests.), (ryzen-5950x-1). This is an experimental job that does not run on a fixed schedule.')
  }
  environment {
    LC_ALL = 'C.UTF-8'
  }
  stages {
    stage('test') { parallel {

      stage('v1.25') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.v1_25 }
        }
        steps {
          runRegressiontest('maintenance/v1.25', 'v1.25', '', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false)
        }
      }

      stage('v1.26') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.v1_26 }
        }
        steps {
          runRegressiontest('maintenance/v1.26', 'v1.26', '', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false)
        }
      }

      stage('master') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.master }
        }
        steps {
          runRegressiontest('master', 'master', '', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false)
        }
      }

      stage('conversion script') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.conversion_script }
        }
        steps {
          runRegressiontest('master', 'conversion', '', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, true)
        }
      }

      stage('newInst-newBackend') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.newInst_newBackend }
        }
        steps {
          runRegressiontest('master', 'newInst-newBackend', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck --newBackend")', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false)
        }
      }

      stage('v1.25 FMI with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmi_v1_25 }
        }
        steps {
          runRegressiontest('maintenance/v1.25', 'v1.25-fmi', '', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('v1.26 FMI with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmi_v1_26 }
        }
        steps {
          runRegressiontest('maintenance/v1.26', 'v1.26-fmi', '', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('master FMI with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmi_master }
        }
        steps {
          runRegressiontest('master', 'master-fmi', '', 'origin/master', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('v1.25 CVODE CS-FMUs with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cs_fmu_cvode_v1_25 }
        }
        steps {
          runRegressiontest('maintenance/v1.25', 'v1.25-cs-fmu-cvode', 'setCommandLineOptions("--fmiFlags=s:cvode --fmuRuntimeDepends=modelica")', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('v1.26 CVODE CS-FMUs with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cs_fmu_cvode_v1_26 }
        }
        steps {
          runRegressiontest('maintenance/v1.26', 'v1.26-cs-fmu-cvode', 'setCommandLineOptions("--fmiFlags=s:cvode --fmuRuntimeDepends=modelica")', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('master CVODE CS-FMUs with OMSimulator') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cs_fmu_cvode_master }
        }
        steps {
          runRegressiontest('master', 'master-cs-fmu-cvode', 'setCommandLineOptions("--fmiFlags=s:cvode --fmuRuntimeDepends=modelica")', 'origin/master', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('v1.25 FMI with FMPy') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmpy_fmi_v1_25 }
        }
        steps {
          runRegressiontest('maintenance/v1.25', 'v1.25-fmi-fmpy', '', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('v1.26 FMI with FMPy') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmpy_fmi_v1_26 }
        }
        steps {
          runRegressiontest('maintenance/v1.26', 'v1.26-fmi-fmpy', '', omsimulatorHash(), 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('master FMI with FMPy') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.fmpy_fmi_master }
        }
        steps {
          runRegressiontest('master', 'master-fmi-fmpy', '', 'origin/master', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('newInst-daeMode') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.newInst_daeMode }
        }
        steps {
          runRegressiontest('master', 'newInst-daeMode', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck --daeMode=true")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('newBackend-daeMode') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.newBackend_daeMode }
        }
        steps {
          runRegressiontest('master', 'newBackend-daeMode', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck --newBackend --daeMode=true")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('oldInst') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.oldInst }
        }
        steps {
          runRegressiontest('master', 'oldInst', 'setCommandLineOptions("-d=nonewInst")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('cvode') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cvode }
        }
        steps {
          runRegressiontest('master', 'cvode', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '-s cvode', false, false)
        }
      }
      stage('gbode') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.gbode }
        }
        steps {
          runRegressiontest('master', 'gbode', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '-s gbode -gbnls=internal -gberr=embedded -gbm=esdirk4', false, false)
        }
      }
      stage('ida') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.ida }
        }
        steps {
          runRegressiontest('master', 'ida', 'setCommandLineOptions("-d=newInst,-frontEndUnitCheck")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '-s ida', false, false)
        }
      }
      stage('generateSymbolicJacobian') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.generateSymbolicJacobian }
        }
        steps {
          runRegressiontest('master', 'generateSymbolicJacobian', 'setCommandLineOptions("--generateSymbolicJacobian")', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false)
        }
      }
      stage('heavy_tests') {
        agent {
          node {
            label 'ryzen-5950x-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.heavy_tests }
        }
        steps {
            runRegressiontest('master', 'heavy_tests', '', '', 'ripper1', 'LibraryTestingRipper1DB', false, '', false, false, 1, 'configs/heavy_tests.json')
        }
      }

      stage('C++ v1.25') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cpp_v1_25 }
        }
        steps {
          runRegressiontest('maintenance/v1.25', 'v1.25-cpp', 'setCommandLineOptions("--simCodeTarget=Cpp")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
      stage('C++ v1.26') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cpp_v1_26 }
        }
        steps {
          runRegressiontest('maintenance/v1.26', 'v1.26-cpp', 'setCommandLineOptions("--simCodeTarget=Cpp")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }

      stage('C++') {
        agent {
          node {
            label 'ryzen-5950x-2-1'
            customWorkspace 'ws/OpenModelicaLibraryTestingWork'
          }
        }
        options { skipDefaultCheckout() }
        when {
          beforeAgent true
          expression { params.cpp }
        }
        steps {
          runRegressiontest('master', 'cpp', 'setCommandLineOptions("--simCodeTarget=Cpp")', '', 'ripper2', 'LibraryTestingRipper2DB', false, '', false, false)
        }
      }
    } }
    stage('report') { parallel {
      stage('ryzen-5950x-1') {
        agent {
          dockerfile {
            label 'linux'
            dir '.CI/build-dep'
            customWorkspace 'ws/OpenModelicaLibraryTestingReport'
            args '-e IDA_EMAIL_USR=$IDA_EMAIL_USR -e IDA_EMAIL_PSW=$IDA_EMAIL_PSW'
          }
        }
        when {
          beforeAgent true
          expression { params.v1_25 || params.v1_26 || params.master || params.conversion_script || params.report_ryzen_5950x_1 | params.newInst_newBackend || params.generateSymbolicJacobian || params.heavy_tests}
        }
        environment {
          GITBRANCHES = 'maintenance/v1.20 maintenance/v1.21 maintenance/v1.22 maintenance/v1.23 maintenance/v1.24 maintenance/v1.25 maintenance/v1.26 master newInst-newBackend'
          PYTHONIOENCODING = 'utf-8'
          IDA_EMAIL = credentials('IDA email')
        }
        steps {
          //sshagent (credentials: ['Hudson-SSH-Key']) {
          //  createInitialHistoryFilesOnRemote()
          //}
          sh 'rm -rf sqlite3.db *.html history'
          sh '''
          if ! test -d OpenModelica; then
            git clone https://openmodelica.org/git-readonly/OpenModelica.git
          fi
          cd OpenModelica
          git fetch
          '''
          sh 'wget -q https://libraries.openmodelica.org/sqlite3/ripper1/sqlite3.db'
          sh './clean-empty-omcversion-dates.py'

          sh "./all-reports.py --email --omcgitdir=OpenModelica ${env.GITBRANCHES} conversion heavy_tests"
          sh "./all-plots.py ${env.GITBRANCHES}"

          sh "./report.py --branches='${env.GITBRANCHES}' configs/conf.json configs/conf-old.json configs/conf-nonstandard.json"
          sh 'mv overview.html overview-combined.html'
          sh "./report.py --branches='${env.GITBRANCHES}' configs/conf-old.json"
          sh "mv overview.html overview-old-libs.html"
          sh "./report.py --branches='${env.GITBRANCHES}' configs/conf-nonstandard.json"
          sh "mv overview.html overview-nonstandard-libs.html"
          sh "./report.py --branches='master conversion' configs/conf.json"
          sh "mv overview.html overview-special-jobs.html"

          sh "./report.py --branches='generateSymbolicJacobian' configs/conf.json"
          sh "mv overview.html overview-generateSymbolicJacobian.html"

          sh "./report.py --branches='heavy_tests' configs/heavy_tests.json"
          sh "mv overview.html overview-heavy_tests.html"

          sh "./report.py --branches='${env.GITBRANCHES}' configs/conf.json"

          sh 'date'
          sh 'find overview*.html history -type f | wc -l'
          sh 'find overview*.html history'

          sshPublisher(publishers: [sshPublisherDesc(configName: 'LibraryTestingReports', transfers: [sshTransfer(sourceFiles: 'overview*.html,history/**')])])

        }
      }

      stage('ryzen-5950x-2') {
        agent {
          dockerfile {
            label 'linux'
            dir '.CI/build-dep'
            customWorkspace 'ws/OpenModelicaLibraryTestingReport'
            args '-e IDA_EMAIL_USR=$IDA_EMAIL_USR -e IDA_EMAIL_PSW=$IDA_EMAIL_PSW'
          }
        }
        when {
          beforeAgent true
          expression { params.fmi_v1_25 || params.fmi_v1_26 || params.fmi_master || params.fmpy_fmi_v1_25 || params.fmpy_fmi_v1_26 || params.fmpy_fmi_master || params.newInst_daeMode || params.newBackend_daeMode || params.oldInst || params.report_ryzen_5950x_2 || params.cpp || params.cvode || params.gbode || params.ida}
        }
        environment {
          GITBRANCHES_FMI = 'maintenance/v1.20-fmi maintenance/v1.21-fmi maintenance/v1.22-fmi maintenance/v1.23-fmi maintenance/v1.24-fmi maintenance/v1.25-fmi maintenance/v1.26-fmi maintenance/v1.22-fmi-fmpy maintenance/v1.23-fmi-fmpy maintenance/v1.24-fmi-fmpy maintenance/v1.25-fmi-fmpy maintenance/v1.26-fmi-fmpy master-fmi master-fmi-fmpy'
          GITBRANCHES_NEWINST = 'oldInst'
          GITBRANCHES_DAE = 'newInst-daeMode'
          GITBRANCHES_NEWBACKEND_DAE = 'newBackend-daeMode'
          GITBRANCHES_CPP = 'v1.19-cpp v1.20-cpp v1.21-cpp v1.22-cpp v1.23-cpp v1.24-cpp v1.25-cpp cpp v1.26-cpp cpp'
          PYTHONIOENCODING = 'utf-8'
          IDA_EMAIL = credentials('IDA email')
        }
        steps {
          //sshagent (credentials: ['Hudson-SSH-Key']) {
          //  createInitialHistoryFilesOnRemote()
          //}
          sh 'rm -f sqlite3.db *.html'
          sh '''
          if ! test -d OpenModelica; then
            git clone https://openmodelica.org/git-readonly/OpenModelica.git
          fi
          cd OpenModelica
          git fetch
          '''
          sh 'wget -q https://libraries.openmodelica.org/sqlite3/ripper2/sqlite3.db'
          sh './clean-empty-omcversion-dates.py'

          sh "./all-reports.py --email --omcgitdir=OpenModelica ${env.GITBRANCHES_FMI} ${env.GITBRANCHES_NEWINST} ${env.GITBRANCHES_DAE} ${env.GITBRANCHES_NEWBACKEND_DAE} ${env.GITBRANCHES_CPP} gbode cvode ida"
          sh "./all-plots.py ${env.GITBRANCHES_FMI} ${env.GITBRANCHES_NEWINST} ${env.GITBRANCHES_DAE} ${env.GITBRANCHES_NEWBACKEND_DAE} ${env.GITBRANCHES_CPP} gbode cvode ida"

          sh "./report.py --branches='${env.GITBRANCHES_NEWINST}' configs/conf.json"
          sh "mv overview.html overview-oldinst.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWINST}' configs/conf.json configs/conf-old.json configs/conf-nonstandard.json"
          sh "mv overview.html overview-combined-oldinst.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWINST}' configs/conf-old.json"
          sh "mv overview.html overview-old-libs-oldinst.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWINST}' configs/conf-nonstandard.json"
          sh "mv overview.html overview-nonstandard-libs-oldinst.html"

          sh "./report.py --branches='${env.GITBRANCHES_FMI}' configs/conf.json"
          sh "mv overview.html overview-fmi.html"
          sh "./report.py --branches='${env.GITBRANCHES_FMI}' configs/conf.json configs/conf-old.json configs/conf-nonstandard.json"
          sh "mv overview.html overview-combined-fmi.html"
          sh "./report.py --branches='${env.GITBRANCHES_FMI}' configs/conf-old.json"
          sh "mv overview.html overview-old-libs-fmi.html"
          sh "./report.py --branches='${env.GITBRANCHES_FMI}' configs/conf-nonstandard.json"
          sh "mv overview.html overview-nonstandard-libs-fmi.html"

          sh "./report.py --branches='${env.GITBRANCHES_DAE}' configs/conf.json"
          sh "mv overview.html overview-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_DAE}' configs/conf.json configs/conf-old.json  configs/conf-nonstandard.json"
          sh "mv overview.html overview-combined-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_DAE}' configs/conf-old.json"
          sh "mv overview.html overview-old-libs-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_DAE}' configs/conf-nonstandard.json"
          sh "mv overview.html overview-nonstandard-libs-dae.html"

          sh "./report.py --branches='${env.GITBRANCHES_NEWBACKEND_DAE}' configs/conf.json"
          sh "mv overview.html overview-newbackend-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWBACKEND_DAE}' configs/conf.json configs/conf-old.json configs/conf-nonstandard.json"
          sh "mv overview.html overview-combined-newbackend-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWBACKEND_DAE}' configs/conf-old.json"
          sh "mv overview.html overview-old-libs-newbackend-dae.html"
          sh "./report.py --branches='${env.GITBRANCHES_NEWBACKEND_DAE}' configs/conf-nonstandard.json"
          sh "mv overview.html overview-nonstandard-libs-newbackend-dae.html"

          sh "./report.py --branches='cvode' configs/conf.json"
          sh "mv overview.html overview-cvode.html"

          sh "./report.py --branches='gbode' configs/conf.json"
          sh "mv overview.html overview-gbode.html"

          sh "./report.py --branches='ida' configs/conf.json"
          sh "mv overview.html overview-ida.html"

          sh "./report.py --branches='${env.GITBRANCHES_CPP}' configs/conf.json"
          sh "mv overview.html overview-c++.html"

          sh 'date'
          sh 'find overview*.html history -type f | wc -l'
          sh 'find overview*.html history'

          sshPublisher(publishers: [sshPublisherDesc(configName: 'LibraryTestingReports', transfers: [sshTransfer(sourceFiles: 'overview-*.html,history/**')])])

        }
      }
    } }
  }
}
def omsimulatorHash() {
  return 'master'
}
def installLibraries(boolean removePackageOrder, boolean conversionScript, name, String omhomeTestedOMC) {
  sh "rm -rf '${env.HOME}/saved_omc/libraries/.openmodelica/libraries'"
  sh "mkdir -p '${env.HOME}/saved_omc/libraries/'"
  sh "HOME='${env.HOME}/saved_omc/libraries/' /usr/bin/omc OpenModelicaLibraryTesting/.CI/installLibraries.mos"
  if (removePackageOrder) {
    sh "find '${env.HOME}/saved_omc/libraries/' -name package.order -exec rm '{}' ';'"
  }
  // These exist (better packaged? on the machines)
  sh "rm -rf '${env.HOME}/saved_omc/libraries/ClaRa' '${env.HOME}/saved_omc/libraries/ClaRa_Obsolete' '${env.HOME}/saved_omc/libraries/TILMedia'"
  sh "cp -ai /mnt/ReferenceFiles/ExtraLibs/packaged/* '${env.HOME}/saved_omc/libraries/'"
  echo "installLibraries removePackageOrder: ${removePackageOrder} conversionScript: ${conversionScript} name: ${name}"
  if (conversionScript) {
    sh """
    cd '${WORKSPACE}/OpenModelicaLibraryTesting'
    OPENMODELICAHOME="${omhomeTestedOMC}" ./conversionscript.py --diff --allowErrorsInDiff '${env.HOME}/saved_omc/libraries/.openmodelica/libraries'
    scp converted-libraries/.openmodelica/libraries/*.diff 'libraries.openmodelica.org:/var/www/libraries.openmodelica.org/branches/${name}'
    """
    return "${WORKSPACE}/OpenModelicaLibraryTesting/converted-libraries"
  } else {
    return "${env.HOME}/saved_omc/libraries"
  }
}


def createInitialHistoryFilesOnRemote() {
  sh """
HISTORY_DIRECTORY='/var/www/libraries.openmodelica.org/branches/history/'
SEPARATOR='/'
HISTORY_FILE='00_history.html'

for b in ${env.GITBRANCHES} ${env.GITBRANCHES_FMI} ${env.GITBRANCHES_NEWINST} ${env.GITBRANCHES_DAE} ${env.GITBRANCHES_CPP}; do
 BRANCH=`echo \${b} | cut -d '/' -f2`
 FILE="\${HISTORY_DIRECTORY}\${BRANCH}\${SEPARATOR}\${HISTORY_FILE}"
ssh hudson@build.openmodelica.org << EOF
if [ ! -f \${FILE} ]; then
  echo "Creating initial history: library.openmodelica.org: \${FILE}"
  mkdir -p \${HISTORY_DIRECTORY}\${BRANCH}
  touch \${FILE}
fi
EOF
done
"""
}

/**
  * Launches the test.py script with the given options.
  *
  * @param branch:              OpenModelica branch to test. Will checkout the branch and build omc from it.
  * @param name:                Unique name of the library test. Passed to test.py via flag `--branch`.
  *                             Also used for stashing omc and uploading results to https://test.openmodelica.org.
  * @param extraFlags:          Additional compiler flags passed to test.py via flag `--extraflags`.
  * @param omsHash:             OMSimulator SHA.
  * @param dbPrefix:            Prefix for test results data base `sqlite3.db`.
  * @parm sshConfig:            SSH configuration saved on test node.
  * @param omcompiler:          Checkout old OMCompiler submodule. Should be `false` nowadays.
  * @param extrasimflags:       Additional simulation flags passed to test.py via flag `--extrasimflags`.
  * @param removePackageOrder:  Passed to `installLibraries`.
  * @param conversionScript:    Passed to `installLibraries`.
  * @param jobs:                The number of tests/jobs to launch in parallel.
  *                             By default this is set to `0` which means launch as many tests as there are available
  *                             physical cpus on the machine'.
  * @param libs_config_file:    The config file to be used for testing.
  *                             This file specifies which libraries to test and what options to use for them.
  */
def runRegressiontest(branch, name, extraFlags, omsHash, dbPrefix, sshConfig, omcompiler, extrasimflags, boolean removePackageOrder, boolean conversionScript, int jobs=0, libs_config_file = 'configs/conf.json') {
  sh '''
  find /tmp  -name "*openmodelica.hudson*" -exec rm {} ";" || true
  mkdir -p ~/TEST_LIBS_BACKUP
  find ~/TEST_LIBS_BACKUP -name *sqlite3.*.db -mtime +7 -exec rm {} ";"

  if test -z "$WORKSPACE"; then
    echo "Odd workspace"
    exit 1
  fi
  '''
  FMI_TESTING_FLAG=""
  if (!name.contains('fmpy') && omsHash) {
    sh """
    if ! test -d OMSimulator; then
      git clone --recursive https://openmodelica.org/git-readonly/OMSimulator.git || exit 1
    fi
    cd OMSimulator || exit 1

    git fetch || exit 1
    git reset --hard "${omsHash}" || exit 1

    git rev-parse HEAD > .newhash
    echo "OMSimulator Hash: ${omsHash} and commit:"
    cat .newhash || true
    echo Old Hash:
    cat ~/saved_omc/OMSimulator/.githash || true

    if ! (cmp ~/saved_omc/OMSimulator/.githash .newhash); then

      git submodule update || exit 1
      git clean -fdx || exit 1
      git submodule foreach --recursive  "git fetch --tags && git reset --hard && git clean -fdxq -e /git -e /svn" || exit 1
      cmake -S . -B build/ -DCMAKE_INSTALL_PREFIX=install/
      cmake --build build/ --target install || exit 1
      ./install/bin/OMSimulator --version || exit 1
      mkdir -p ~/saved_omc/OMSimulator || exit 1
      cp -a * ~/saved_omc/OMSimulator/ || exit 1
      git rev-parse HEAD > ~/saved_omc/OMSimulator/.githash || exit 1

    fi
    echo OMSimulator version:
    ${env.HOME}/saved_omc/OMSimulator/install/bin/OMSimulator --version
    """
    FMI_TESTING_FLAG="--fmi=true --fmisimulator=${env.HOME}/saved_omc/OMSimulator/install/bin/OMSimulator --default=ulimitExe=50"
    if (name.contains('cvode')) {
      FMI_TESTING_FLAG += " --fmuType=cs"
    }
  }

  if (name.contains('fmpy')) {
    sh """
    # update fmpy
    pip install FMPy || true
    python3 -m fmpy -h || exit 1
    """
    FMI_TESTING_FLAG="--fmi=true --fmisimulator='python3 -m fmpy' --default=ulimitExe=50"
  }

  OMCPATH = "${omcompiler ? '../' : './'}OMCompiler"

  sh '''
  FREE=`df -k --output=avail "$PWD" | tail -n1`   # df -k not df -h
  if test "$FREE" -lt 31457280; then               # 30G = 30*1024*1024k
    echo "Less than 30 GB free disk space"
    exit 1
  fi;
  '''

  sh 'killall omc || true'

  sh """
  if test ! -d OpenModelica; then
    git clone --recursive https://openmodelica.org/git-readonly/OpenModelica.git OpenModelica
  fi
  if test ! -d OMCompiler; then
    git clone --recursive https://openmodelica.org/git-readonly/OMCompiler.git OMCompiler
  fi
  if test ! -d OMLibraries; then
    git clone --recursive https://openmodelica.org/git-readonly/OMLibraries.git OMLibraries
  fi
  cd OMLibraries
  git fetch
  git reset --hard origin/library-coverage

  cd ../OpenModelica
  git fetch
  rm -rf OMCompiler # Make sure the old submodule is not there
  git reset --hard origin/master
  git clean -fdx

  cd ${OMCPATH}

  if ! test -f ~/saved_omc/${name}/.nogit; then
    git reset --hard && git checkout -f "${branch}" && (git rev-parse --verify "tags/${branch}"  || (git reset --hard "origin/${branch}" && git pull)) && git fetch --tags || exit 1
    git submodule update --init --recursive --force || (rm -rf * && git reset --hard && git submodule update --init --recursive --force) || exit 1
    git submodule foreach --recursive  "git fetch --tags && git reset --hard && git clean -fdxq -e /git -e /svn" || exit 1
    git clean -fdxq || exit 1
    git submodule status --recursive
  fi

  export OPENMODELICAHOME="`pwd`/build"

  git rev-parse --verify HEAD > .newhash
  echo New Hash:
  cat .newhash
  echo Old Hash:
  cat ~/saved_omc/${name}/.githash || true
  # TODO: Create a docker image for these things instead?
  if ! (cmp ~/saved_omc/${name}/.githash .newhash || test -f ~/saved_omc/${name}/.nogit); then
    autoreconf --install
    ./configure --with-cppruntime --without-omc --disable-modelica3d CC=clang CXX=clang++ FC=gfortran CFLAGS='-O2 -march=native' --with-omlibrary=all --with-omniORB
    time make -j16 clean
    if ! time make -j9 omc > log 2>&1; then
      cat log
      exit 1
    fi
    if ! time make -j16 runtimeCPPinstall > log 2>&1; then
      cat log
      if test "${name}" = "master"; then
        exit 1
      else
        echo "Ignoring failed C++ runtime"
      fi
    fi
    rm -rf ~/saved_omc/${name}/
    mkdir -p ~/saved_omc/${name}/
    CMD="rsync -a --delete build/ \$HOME/saved_omc/${name}/"
    echo \$CMD
    \$CMD || exit 1
    cp .newhash ~/saved_omc/${name}/.githash
  else
    rsync -a --delete ~/saved_omc/${name}/ build/ || exit 1
    echo "Restoring cached OMC version: ${name}, `cat ~/saved_omc/${name}/.githash`"
  fi
  """

  sh """
  cd OpenModelica
  rm -rf "`pwd`/${OMCPATH}/build/lib/omlibrary/"
  mkdir -p "`pwd`/${OMCPATH}/build/lib/omlibrary/"
  # (cd ../OMLibraries && git rev-parse HEAD)
  # if ! time make -j16 -C ../OMLibraries all BUILD_DIR="`pwd`/${OMCPATH}/build/lib/omlibrary/" > log 2>&1; then
  #   cat log
  #   exit 1
  # fi
  if ! time make -j16 -C testsuite/ReferenceFiles > log 2>&1; then
    cat log
    exit 1
  fi

  cd ../
  rm -rf Reference-modelica.org
  ln -s /mnt/ReferenceFiles/modelica.org Reference-modelica.org
  """
  // sh 'rsync -av modelica-ro:/files/RegressionTesting/ReferenceResults Reference-modelica.org || true # exit 1'

  MSLREFERENCE="${WORKSPACE}/Reference-modelica.org/ReferenceResults"
  REFERENCEFILES="${WORKSPACE}/OpenModelica/testsuite/ReferenceFiles"
  GITREPOS="${WORKSPACE}/OpenModelica/libraries/git"
  PNLIBREFS="/mnt/ReferenceFiles/PNlib/ReferenceFiles"
  THERMOFLUIDSTREAMREFS="/mnt/ReferenceFiles/ThermofluidStream-main-regression/ReferenceData"
  THERMOFLUIDSTREAMREFSOM="/mnt/ReferenceFiles/ThermofluidStream-OM-regression/ReferenceData"

  sh """
  test -f "${MSLREFERENCE}/MAP-LIB_ReferenceResults/v4.0.0/README.md" || exit 1

  if test ! -d OpenModelicaLibraryTesting; then
    git clone --recursive https://openmodelica.org/git-readonly/OpenModelicaLibraryTesting.git OpenModelicaLibraryTesting
  fi
  cd OpenModelicaLibraryTesting
  git fetch
  git reset --hard origin/master

  mkdir -p "/var/www/libraries.openmodelica.org/branches/${name}/"
  """

  def libraryPath = installLibraries(removePackageOrder, conversionScript, name, "${WORKSPACE}/OpenModelica/${OMCPATH}/build")

  sh "test -d '${libraryPath}/.openmodelica/libraries/Modelica trunk'"

  sh """
  if ! test -f ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db; then
    wget -O ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db.tmp -q https://libraries.openmodelica.org/sqlite3/${dbPrefix}/sqlite3.db
	mv ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db.tmp ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db
  fi
  cp ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db OpenModelicaLibraryTesting/sqlite3.db
  test -s OpenModelicaLibraryTesting/sqlite3.db
  """

  sh 'date'

  sh """
  export OPENMODELICAHOME="${WORKSPACE}/OpenModelica/${OMCPATH}/build"
  export MSLREFERENCE="${MSLREFERENCE}"
  export REFERENCEFILES="${REFERENCEFILES}"
  export GITREPOS="${GITREPOS}"
  export PNLIBREFS="${PNLIBREFS}"
  export THERMOFLUIDSTREAMREFS="${THERMOFLUIDSTREAMREFS}"
  export THERMOFLUIDSTREAMREFSOM="${THERMOFLUIDSTREAMREFSOM}"
  export PREVIOUSHOME="${env.HOME}"
  export HOME="${libraryPath}"
  # we need to do some crap magic here to make sure python3 finds fmpy as we change the HOME here
  # too bad if we cannot do it, just continue
  ln -s -t \${HOME} \${PREVIOUSHOME}/.local .local || true

  cd OpenModelicaLibraryTesting
  # Force /usr/bin/omc as being used for generating the mos-files. Ensures consistent behavior among all tested OMC versions
  stdbuf -oL -eL time ./test.py --ompython_omhome=/usr ${FMI_TESTING_FLAG} --extraflags='${extraFlags}' --extrasimflags='${extrasimflags}' --branch="${name}" --output="libraries.openmodelica.org:/var/www/libraries.openmodelica.org/branches/${name}/" --libraries='${libraryPath}/.openmodelica/libraries/'  --jobs=${jobs} ${libs_config_file} ${params.OLDLIBS ? "configs/conf-old.json configs/conf-nonstandard.json" : ""} || (killall omc ; false) || exit 1
  """
  sh 'date'
  sh "rm -f OpenModelicaLibraryTesting/${dbPrefix}-sqlite3.db.tmp"
  sh "ln OpenModelicaLibraryTesting/sqlite3.db OpenModelicaLibraryTesting/${dbPrefix}-sqlite3.db.tmp"
  sh "cd OpenModelicaLibraryTesting/ && ./clean-empty-omcversion-dates.py"
  sh "cp OpenModelicaLibraryTesting/sqlite3.db ~/TEST_LIBS_BACKUP/${dbPrefix}-sqlite3.db"
  sh "rm -f ~/TEST_LIBS_BACKUP/${dbPrefix}-`date +sqlite3.%Y%m%d.db`"

  sshPublisher(publishers: [sshPublisherDesc(configName: sshConfig, transfers: [sshTransfer(removePrefix: 'OpenModelicaLibraryTesting', sourceFiles: 'OpenModelicaLibraryTesting/sqlite3.db')])], failOnError: true)
}