diff --git a/README.md b/README.md
index 625ecbfd71b938eae7e375614a10752b25551083..bdd23ed0c1b4633ee60430b02bdae2c825b5fd0c 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,10 @@ Please visit the [official Parasoft website](http://www.parasoft.com) for more i
   - [Quick start](#quick-start-sa)
   - [Example Pipelines](#example-pipelines-sa)
   - [Reviewing Analysis Results](#reviewing-analysis-results-sa)
+- [Unit Tests](#unit-tests)
+  - [Quick start](#quick-start-ut)
+  - [Example Pipelines](#example-pipelines-ut)
+  - [Reviewing Test Results](#reviewing-test-results-ut)
 - [Code Coverage](#code-coverage)
   - [Quick start](#quick-start-cc)
   - [Example Pipelines](#example-pipelines-cc)
@@ -226,12 +230,166 @@ You can define a merge request policy for your integration branch that will bloc
 1. In the **Policy details** section, define a rule for Static Application Security Testing (select “IF SAST…”). Configure additional options, if needed.
 
 
+## Unit Tests
+### <a name="quick-start-ut"></a> Quick start
+To collect test executions results for your code with Parasoft C/C++test and review test results in GitLab, you need to customize your pipeline to include a job that will:
+  - build your project with unit tests instrumentation enabled.
+  - execute the instrumented application.
+  - generate C/C++test unit tests reports.
+  - convert C/C++test unit tests report to xUnit format (using Saxon).
+  - upload the xUnit report.
+
+#### Prerequisites
+* This extension requires Parasoft C/C++test 2020.2 (or newer) with a valid Parasoft license.
+* We recommend that you execute the pipeline on a GitLab runner with the following components installed and configured on the runner:
+  - C/C++ build toolchain
+  - Parasoft C/C++test 2020.2 (or newer)
+  - On Windows, we recommend that you use PowerShell Core 6 or later. If you use Windows PowerShell 5.1, you must ensure the correct file encoding - see the example pipelines for details.
+
+* To support xUnit format, you need the following files to be accessible on a GitLab runner:
+  - Saxon-HE, which you can copy the folder from [here](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) or download from [Saxonica](https://www.saxonica.com/download/java.xml).
+  - [XSLT file](xsl/cpptest-standard-xunit/xunit.xsl) for transforming C/C++test Standard unit tests report to xUnit report.
+  - [XSLT file](xsl/cpptest-professional-xunit/xunit.xsl) for transforming C/C++test Professional unit tests report to xUnit report.
+
+### <a name="example-pipelines-ut"></a> Example Pipelines
+The following examples show simple pipelines for Make and CMake-based projects. The examples assume that C/C++test is run on a GitLab runner and the path to the `cpptestcli` executable is available on `$PATH`.
+
+
+##### Run C/C++test Standard with CMake project
+For details on how to configure project for unit tests, see [Integrating with CppUnit and CppUtest](https://docs.parasoft.com/display/CPPTEST20232/Integrating+with+CppUnit+and+CppUtest).  
+See also the example [.gitlab-ci.yml](pipelines/unit/cpptest-standard-cmake/.gitlab-ci.yml) file.
+```yaml
+# This is a basic pipeline to help you get started with C/C++test integration to collect unit tests results for a CMake-based project.
+
+# Be sure to configure variables below.
+variables:
+  CMAKE_APP_NAME: "app-executable"
+  CPPTEST_UT_LOG_FILE: "path/to/cpptest-ut-log-file"
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+
+stages:
+  - test
+
+# Runs unit tests with C/C++test.
+cpptest-unit-tests:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+
+  stage: test
+
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Configures your CMake project.
+    - echo "Configuring project..."
+    - cmake -S . -B build
+
+    # Builds your CMake project.
+    - echo "Building project"
+    - cmake --build build
+
+    # Run the instrumented application to generate unit tests log file (.utlog).
+    - echo "Run the instrumented application"
+    - build/$CMAKE_APP_NAME
+
+    # Generate unit tests report
+    - echo "Generating unit tests report"
+    - cpptestcli -config "builtin://Unit Testing" -input $CPPTEST_UT_LOG_FILE -report $CPPTEST_REPORTS_DIR
+
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
+```
+
+##### Run C/C++test Professional with Make project
+For details on how to configure project for unit tests, see [Testing from the Command Line Interface](https://docs.parasoft.com/display/CPPTESTPROVS20232/Testing+from+the+Command+Line+Interface).  
+See also the example [.gitlab-ci.yml](pipelines/unit/cpptest-professional-make/.gitlab-ci.yml) file.
+
+```yaml
+# This is a basic pipeline to help you get started with C/C++test integration to collect unit tests results for a Make-based project.
+
+# Be sure to configure variables below.
+variables:
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+
+stages:
+  - build
+  - test
+
+build-make:
+  stage: build
+  script:
+    # Builds your Make project using 'cpptesttrace' to collect input data for handle test executions results.
+    # Be sure 'cpptesttrace' is available on $PATH.
+    - echo "Building project..."
+    - cpptesttrace make clean all
+  artifacts:
+    # Archives cpptestscan.bdf so that it can be used in the 'test' stage.
+    paths:
+      - cpptestscan.bdf
+
+# Runs unit test with C/C++test.
+cpptest-unit-tests:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+    RESOURCE_PROJECT_FOLDER_NAME: "resource project folder name"
+    LOCALSETTINGS_FILE_PATH: "path/to/localsettings/properties/file"
+
+  stage: test
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Launches C/C++test.
+    - echo "Running C/C++test..."
+    # Generate unit tests
+    - echo "Generate unit tests"
+    - cpptestcli -config "builtin://Generate Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf
+    # Run unit tests
+    - echo "Run unit tests"
+    # Use the following command line when using cpptest professional prior to v2024.1
+    # - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf -report $CPPTEST_REPORTS_DIR
+
+    # Use the following command line when using cpptest professional v2024.1
+    - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf -property report.additional.report.dir=$CPPTEST_REPORTS_DIR
+
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+  after_script:
+    # Removes the workspace folder.
+    - rm -rf $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
+```
+
+### <a name="reviewing-test-results-ut"></a> Reviewing Test Results
+When the pipeline completes, you can review the test results collected by C/C++test in the *Tests* tab of the GitLab pipeline.
+
+
 ## Code Coverage
 ### <a name="quick-start-cc"></a> Quick start
 
-To collect code coverage with Parasoft C/C++test Standard and review coverage results in GitLab, you need to:
-* Integrate C/C++test with your C/C++ build to enable code coverage instrumentation. See also [Collecting Code Coverage](https://docs.parasoft.com/display/CPPTEST20231/Collecting+Code+Coverage).
-* Customize your pipeline to include a job that will:
+To collect code coverage with Parasoft C/C++test and review coverage results in GitLab, you need to customize your pipeline to include a job that will:
   - build your project with code coverage instrumentation enabled.
   - execute the instrumented application.
   - generate C/C++test coverage reports.
@@ -239,14 +397,15 @@ To collect code coverage with Parasoft C/C++test Standard and review coverage re
   - upload the coverage reports.
 
 #### Prerequisites
-* This extension requires Parasoft C/C++test Standard 2021.2 (or newer) with a valid Parasoft license.
+* This extension requires Parasoft C/C++test 2020.2 (or newer) with a valid Parasoft license.
 * We recommend that you execute the pipeline on a GitLab runner with the following components installed and configured on the runner:
    - C/C++ build toolchain
-   - Parasoft C/C++test Standard 2021.2 (or newer)
+   - Parasoft C/C++test 2020.2 (or newer)
    - On Windows, we recommend that you use PowerShell Core 6 or later. If you use Windows PowerShell 5.1, you must ensure the correct file encoding - see the example pipelines for details.
 * To support Cobertura format, you need the following files to be accessible on a GitLab runner:
-  - Saxon-HE, which you can copy from [here](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) or download from [Saxonica](https://www.saxonica.com/download/java.xml).
-  - [XSLT file](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/cpptest-standard-cobertura/cobertura.xsl) for transforming C/C++test coverage report to Cobertura report.
+  - Saxon-HE, which you can copy the folder from [here](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) or download from [Saxonica](https://www.saxonica.com/download/java.xml).
+  - [XSLT file](xsl/cpptest-standard-cobertura/cobertura.xsl) for transforming C/C++test Standard coverage report to Cobertura report.
+  - [XSLT file](xsl/cpptest-professional-cobertura/cobertura.xsl) for transforming C/C++test Professional coverage report to Cobertura report.
 
 ### <a name="example-pipelines-cc"></a> Example Pipelines
 ##### Run code coverage analysis with C/C++test Standard for CMake project
@@ -322,6 +481,71 @@ cpptest-coverage:
     paths:
       - $CPPTEST_REPORTS_DIR/*
 ```
+##### Run code coverage analysis with C/C++test Professional for Make project
+See also the example [.gitlab-ci.yml](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/pipelines/coverage/cpptest-professional-make/.gitlab-ci.yml) file.
+
+```yaml
+# This is a basic pipeline to help you get started with C/C++test Professional integration to collect code coverage for a Make-based project.
+
+# Be sure to configure variables below.
+variables:
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+
+stages:
+  - test
+
+# Runs code coverage analysis with C/C++test.
+cpptest-coverage:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+
+  stage: test
+
+  # See: https://docs.gitlab.com/ee/ci/testing/code_coverage.html#add-test-coverage-results-using-coverage-keyword
+  coverage: '/ lines \(\d+% covered\)/'
+
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Builds your Make project using 'cpptesttrace' to collect input data for code coverage analysis.
+    # Be sure 'cpptesttrace' is available on $PATH.
+    - echo "Building project..."
+    - cpptesttrace make clean all
+
+    # Launches C/C++test.
+    - echo "Running C/C++test..."
+    - echo "Generating Unit Tests..."
+    - cpptestcli -config "builtin://Generate Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf
+    - echo "Running Unit Tests..."
+    - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -property report.additional.report.dir=$CPPTEST_REPORTS_DIR
+
+    # Converts the coverage report to Cobertura format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    #
+    # When running on Windows, be sure to replace backslashes:
+    #   - $CI_PROJECT_DIR = $CI_PROJECT_DIR.Replace("\", "/")
+    - echo "Generating Cobertura report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/cobertura.xsl" -s:"$CPPTEST_REPORTS_DIR/coverage.xml" -o:"$CPPTEST_REPORTS_DIR/cobertura.xml" -t pipelineBuildWorkingDirectory=$CI_PROJECT_DIR
+
+  after_script:
+    # Removes the workspace folder.
+    - rm -rf $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID
+
+  artifacts:
+    # Uploads code coverage results in the Cobertura format, so that they are displayed in GitLab.
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: $CPPTEST_REPORTS_DIR/cobertura.xml
+    # Uploads all report files (.xml, .html) as build artifacts.
+    paths:
+      - $CPPTEST_REPORTS_DIR/*
+```
 
 ### <a name="reviewing-analysis-results-cc"></a> Reviewing Analysis Results
 When the pipeline triggered by a merge request completes, you can review the code coverage data collected by C/C++test in the file diff view of the GitLab Merge requests.
diff --git a/pipelines/coverage/cpptest-professional-make/gitlab-ci.yml b/pipelines/coverage/cpptest-professional-make/gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5ef07f6729a43b0ca852a4cec3464e3f9e53fa4f
--- /dev/null
+++ b/pipelines/coverage/cpptest-professional-make/gitlab-ci.yml
@@ -0,0 +1,60 @@
+# This is a basic pipeline to help you get started with C/C++test Professional integration to collect code coverage for a Make-based project.
+
+# Be sure to configure variables below.
+variables:
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+
+stages:
+  - test
+
+# Runs code coverage analysis with C/C++test.
+cpptest-coverage:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+
+  stage: test
+
+  # See: https://docs.gitlab.com/ee/ci/testing/code_coverage.html#add-test-coverage-results-using-coverage-keyword
+  coverage: '/ lines \(\d+% covered\)/'
+
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Builds your Make project using 'cpptesttrace' to collect input data for code coverage analysis.
+    # Be sure 'cpptesttrace' is available on $PATH.
+    - echo "Building project..."
+    - cpptesttrace make clean all
+
+    # Launches C/C++test.
+    - echo "Running C/C++test..."
+    - echo "Generating Unit Tests..."
+    - cpptestcli -config "builtin://Generate Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf
+    - echo "Running Unit Tests..."
+    - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -property report.additional.report.dir=$CPPTEST_REPORTS_DIR
+
+    # Converts the coverage report to Cobertura format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    #
+    # When running on Windows, be sure to replace backslashes:
+    #   - $CI_PROJECT_DIR = $CI_PROJECT_DIR.Replace("\", "/")
+    - echo "Generating Cobertura report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/cobertura.xsl" -s:"$CPPTEST_REPORTS_DIR/coverage.xml" -o:"$CPPTEST_REPORTS_DIR/cobertura.xml" -t pipelineBuildWorkingDirectory=$CI_PROJECT_DIR
+
+  after_script:
+    # Removes the workspace folder.
+    - rm -rf $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID
+
+  artifacts:
+    # Uploads code coverage results in the Cobertura format, so that they are displayed in GitLab.
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: $CPPTEST_REPORTS_DIR/cobertura.xml
+    # Uploads all report files (.xml, .html) as build artifacts.
+    paths:
+      - $CPPTEST_REPORTS_DIR/*
diff --git a/pipelines/unit/cpptest-professional-make/.gitlab-ci.yml b/pipelines/unit/cpptest-professional-make/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8a283fd122b96e1356036bcd4914436e673e7b45
--- /dev/null
+++ b/pipelines/unit/cpptest-professional-make/.gitlab-ci.yml
@@ -0,0 +1,59 @@
+# This is a basic pipeline to help you get started with C/C++test integration to collect unit tests results for a Make-based project.
+
+# Be sure to configure variables below.
+variables:
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+
+stages:
+  - build
+  - test
+
+build-make:
+  stage: build
+  script:
+    # Builds your Make project using 'cpptesttrace' to collect input data for handle test executions results.
+    # Be sure 'cpptesttrace' is available on $PATH.
+    - echo "Building project..."
+    - cpptesttrace make clean all
+  artifacts:
+    # Archives cpptestscan.bdf so that it can be used in the 'test' stage.
+    paths:
+      - cpptestscan.bdf
+
+# Runs unit test with C/C++test.
+cpptest-unit-tests:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+    RESOURCE_PROJECT_FOLDER_NAME: "resource project folder name"
+    LOCALSETTINGS_FILE_PATH: "path/to/localsettings/properties/file"
+
+  stage: test
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Launches C/C++test.
+    - echo "Running C/C++test..."
+    # Generate unit tests
+    - echo "Generate unit tests"
+    - cpptestcli -config "builtin://Generate Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf
+    # Run unit tests
+    - echo "Run unit tests"
+    # Use the following command line when using cpptest professional prior to v2024.1
+    # - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf -report $CPPTEST_REPORTS_DIR
+    # Use the following command line when using cpptest professional v2024.1
+    - cpptestcli -config "builtin://Run Unit Tests" -resource $RESOURCE_PROJECT_FOLDER_NAME -localsettings $LOCALSETTINGS_FILE_PATH -data $CI_BUILDS_DIR/cpptest-workspace-$CI_PIPELINE_ID -bdf cpptestscan.bdf -property report.additional.report.dir=$CPPTEST_REPORTS_DIR
+    
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
\ No newline at end of file
diff --git a/pipelines/unit/cpptest-standard-cmake/.gitlab-ci.yml b/pipelines/unit/cpptest-standard-cmake/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b431df68b246fb1ca1d686cf29fa62db9e1e95ff
--- /dev/null
+++ b/pipelines/unit/cpptest-standard-cmake/.gitlab-ci.yml
@@ -0,0 +1,51 @@
+# This is a basic pipeline to help you get started with C/C++test integration to collect unit tests results for a CMake-based project.
+
+# Be sure to configure variables below.
+variables:
+  CMAKE_APP_NAME: "app-executable"
+  CPPTEST_UT_LOG_FILE: "path/to/cpptest-ut-log-file"
+  CPPTEST_INSTALL_DIR: "path/to/cpptest"
+  CPPTEST_XSL_DIR: "path/to/xsl"
+  CPPTEST_SAXON_DIR: "path/to/saxon"
+
+stages:
+  - test
+
+# Runs unit tests with C/C++test.
+cpptest-unit-tests:
+  variables:
+    CPPTEST_REPORTS_DIR: "path/to/reports"
+
+  stage: test
+
+  script:
+    # When running on Windows with PowerShell 5.1, be sure to enforce the default file encoding:
+    # - $PSDefaultParameterValues['Out-File:Encoding'] = 'default'
+
+    # Configures your CMake project.
+    - echo "Configuring project..."
+    - cmake -S . -B build
+
+    # Builds your CMake project.
+    - echo "Building project"
+    - cmake --build build
+
+    # Run the instrumented application to generate unit tests log file (.utlog).
+    - echo "Run the instrumented application"
+    - build/$CMAKE_APP_NAME
+
+    # Generate unit tests report
+    - echo "Generating unit tests report"
+    - cpptestcli -config "builtin://Unit Testing" -input $CPPTEST_UT_LOG_FILE -report $CPPTEST_REPORTS_DIR
+
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
\ No newline at end of file
diff --git a/xsl/cpptest-professional-cobertura/README.md b/xsl/cpptest-professional-cobertura/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b387a6013ad5e7ee9f9fcd6cd5ca27f6a5728f3b
--- /dev/null
+++ b/xsl/cpptest-professional-cobertura/README.md
@@ -0,0 +1,29 @@
+# Generating a Cobertura report with C/C++test Professional
+
+To report Code Coverage results using Cobertura format:
+
+1. Copy the [`cobertura.xsl`](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/cpptest-professional-cobertura/cobertura.xsl) file into a local directory (`<CPPTEST_XSL_DIR>`).
+2. Copy [`Saxon`](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) files into a local directory (`<CPPTEST_SAXON_DIR>`).
+3. Update your GitLab pipeline to convert `<CPPTEST_REPORTS_DIR>/coverage.xml` report into `<CPPTEST_REPORTS_DIR>/cobertura.xml`:
+
+```yaml
+  ...
+    # Converts the coverage report to Cobertura format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    #
+    # When running on Windows, be sure to replace backslashes:
+    #   - $CI_PROJECT_DIR = $CI_PROJECT_DIR.Replace("\", "/")
+    - echo "Generating Cobertura report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/cobertura.xsl" -s:"$CPPTEST_REPORTS_DIR/coverage.xml" -o:"$CPPTEST_REPORTS_DIR/cobertura.xml" -t pipelineBuildWorkingDirectory=$CI_PROJECT_DIR
+
+  artifacts:
+    # Uploads code coverage results in the Cobertura format, so that they are displayed in GitLab.
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: $CPPTEST_REPORTS_DIR/cobertura.xml
+  ...
+```
+4. Run your GitLab pipeline.
diff --git a/xsl/cpptest-professional-cobertura/cobertura.xsl b/xsl/cpptest-professional-cobertura/cobertura.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..086b5f84452b374935c2418ea24c0810c429cb8f
--- /dev/null
+++ b/xsl/cpptest-professional-cobertura/cobertura.xsl
@@ -0,0 +1,451 @@
+<?xml version="1.0" encoding="UTF-8"  standalone="yes"?>
+<xsl:stylesheet version="3.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:map="http://www.w3.org/2005/xpath-functions/map">
+    <xsl:variable name="toolName" select="/Coverage/@toolId"/>
+    <xsl:variable name="toolVer" select="/Coverage/@toolVer"/>
+    <xsl:variable name="toolDispName" select="/Coverage/@toolDispName"/>
+    <xsl:param name="pipelineBuildWorkingDirectory"><xsl:value-of select="/Coverage/@pipelineBuildWorkingDirectory"/></xsl:param>
+
+    <xsl:template name="getUriWithoutFilePrefix">
+        <xsl:param name="rawUri"/>
+        <xsl:choose>
+            <!-- for file:///xxx uri pattern -->
+            <xsl:when test="matches($rawUri, '^file:///([^/\\]+)')">
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, 'file:///')"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- for file://hostname/xxx uri pattern -->
+            <xsl:when test="matches($rawUri, '^file://([^/]+)/([^/\\]+)')">
+                <!-- Extract the hostname from an uri, like: the result is 'hostname' for uri 'file://hostname/C:/abc' -->
+                <xsl:variable name="hostname" select="replace($rawUri, '^file://([^/]+)(/.*)$', '$1')" />
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, concat('file://', $hostname , '/'))"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- for file:/ uri pattern -->
+            <xsl:when test="matches($rawUri, '^file:/([^/\\]+)')">
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, 'file:/')"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$rawUri"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="makeUriSystemCompatible">
+        <xsl:param name="uriWithoutFilePrefix"/>
+        <xsl:choose>
+            <!-- on windows: start with X:/ or X:\ -->
+            <xsl:when test="matches($uriWithoutFilePrefix, '^[A-Za-z]:[/\\]')">
+                <xsl:value-of select="$uriWithoutFilePrefix"/>
+            </xsl:when>
+            <!-- on linux -->
+            <xsl:otherwise>
+                <xsl:value-of select="concat('/', $uriWithoutFilePrefix)"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="/">
+        <xsl:element name="coverage">
+            <xsl:variable name="allLocNodes" select="/Coverage/Locations/Loc"/>
+            <xsl:variable name="linesValid">
+                <xsl:call-template name="getCoverableLineNumber">
+                    <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:if test="$linesValid > 0">
+                <xsl:variable name="linesCovered">
+                    <xsl:call-template name="getCoveredLineNumber">
+                        <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:attribute name="line-rate">
+                    <xsl:value-of select="$linesCovered div $linesValid"/>
+                </xsl:attribute>
+                <xsl:attribute name="lines-covered">
+                    <xsl:value-of select="$linesCovered"/>
+                </xsl:attribute>
+                <xsl:attribute name="lines-valid">
+                    <xsl:value-of select="$linesValid"/>
+                </xsl:attribute>
+                <xsl:attribute name="version">
+                    <xsl:value-of select="$toolDispName"/><xsl:text> </xsl:text><xsl:value-of select="$toolVer"/>
+                </xsl:attribute>
+                <xsl:call-template name="packages"/>
+            </xsl:if>
+        </xsl:element>
+    </xsl:template>
+
+    <xsl:template name="packages">
+        <xsl:element name="packages">
+            <!-- Group by the parent path of uri-->
+            <xsl:for-each-group select="/Coverage/Locations/Loc" group-by="substring-before(@uri, tokenize(@uri, '/')[last()])">
+                <xsl:variable name="theFirstUriWithoutFilePrefixInCurrentGroup">
+                    <xsl:call-template name="getUriWithoutFilePrefix">
+                        <xsl:with-param name="rawUri" select="@uri"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:variable name="lineRateForPacakgeTag">
+                    <xsl:call-template name="getLineRateForPackage">
+                        <xsl:with-param name="locNodesToCalcute" select="current-group()"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:if test="$lineRateForPacakgeTag != -1">
+                    <xsl:element name="package">
+                        <xsl:variable name="uncodedPipelineBuildWorkingDirectory">
+                            <xsl:if test="string($pipelineBuildWorkingDirectory) != ''">
+                                <xsl:value-of select="concat(translate($pipelineBuildWorkingDirectory, '\', '/'), '/')"/>
+                            </xsl:if>
+                        </xsl:variable>
+                        <xsl:variable name="encodedPipelineBuildWorkingDirectory">
+                            <xsl:if test="string($uncodedPipelineBuildWorkingDirectory) != ''">
+                                <!-- Replace % with %25 and space with %20 to get an encoded path-->
+                                <xsl:value-of select="replace(replace($uncodedPipelineBuildWorkingDirectory, '%', '%25'), ' ', '%20')"/>
+                            </xsl:if>
+                        </xsl:variable>
+                        <xsl:variable name="processedPipelineBuildWorkingDirectory">
+                            <xsl:choose>
+                                <xsl:when test="string($uncodedPipelineBuildWorkingDirectory) != '' and contains($theFirstUriWithoutFilePrefixInCurrentGroup, $uncodedPipelineBuildWorkingDirectory)">
+                                    <xsl:value-of select="$uncodedPipelineBuildWorkingDirectory"/>
+                                </xsl:when>
+                                <!-- Using encoded pipeline build working directory when the uri attribute of <Loc> tag in Parasoft tool report(e.g. jtest report) is encoded -->
+                                <xsl:when test="string($encodedPipelineBuildWorkingDirectory) != '' and contains($theFirstUriWithoutFilePrefixInCurrentGroup, $encodedPipelineBuildWorkingDirectory)">
+                                    <xsl:value-of select="$encodedPipelineBuildWorkingDirectory"/>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:value-of select="''"/>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:variable>
+                        <xsl:variable name="isExternalReport" select="$processedPipelineBuildWorkingDirectory = ''"/>
+                        <xsl:variable name="packageName">
+                            <xsl:choose>
+                                <xsl:when test="$isExternalReport">
+                                    <xsl:call-template name="getPackageName">
+                                        <xsl:with-param name="projectPath" select="$theFirstUriWithoutFilePrefixInCurrentGroup"/>
+                                    </xsl:call-template>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:call-template name="getPackageName">
+                                        <!-- Get relative source file path -->
+                                        <xsl:with-param name="projectPath" select="substring-after($theFirstUriWithoutFilePrefixInCurrentGroup, $processedPipelineBuildWorkingDirectory)"/>
+                                    </xsl:call-template>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:variable>
+                        <xsl:attribute name="name">
+                            <xsl:value-of select="$packageName"/>
+                        </xsl:attribute>
+                        <xsl:attribute name="line-rate">
+                            <xsl:value-of select="$lineRateForPacakgeTag"/>
+                        </xsl:attribute>
+                        <xsl:element name="classes">
+                            <xsl:for-each select="current-group()">
+                                <xsl:variable name="sourceFileUriWithoutFilePrefix">
+                                    <xsl:call-template name="getUriWithoutFilePrefix">
+                                        <xsl:with-param name="rawUri" select="@uri"/>
+                                    </xsl:call-template>
+                                </xsl:variable>
+                                <xsl:variable name="filePath">
+                                    <xsl:choose>
+                                        <xsl:when test="$isExternalReport">
+                                            <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                                            <xsl:value-of select="replace(replace($sourceFileUriWithoutFilePrefix, '%25', '%'), '%20', ' ')"/>
+                                        </xsl:when>
+                                        <xsl:otherwise>
+                                            <!-- Get relative source file path -->
+                                            <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                                            <xsl:value-of select="replace(replace(substring-after($sourceFileUriWithoutFilePrefix, $processedPipelineBuildWorkingDirectory), '%25', '%'), '%20', ' ')"/>
+                                        </xsl:otherwise>
+                                    </xsl:choose>
+                                </xsl:variable>
+                                <xsl:variable name="locRef" select="@locRef"/>
+                                <xsl:variable name="cvgDataNode" select="//CvgData[@locRef=$locRef]"/>
+                                <xsl:choose>
+                                    <xsl:when test="$toolName = 'jtest'">
+                                        <xsl:variable name="typeItemNodes" select="$cvgDataNode/Stats//Item[has-children()]"/>
+                                        <xsl:for-each select="$typeItemNodes">
+                                            <xsl:variable name="methodItemRefsUnderCurrentType" select="./Item[not(has-children())]/@itemRef"/>
+                                            <xsl:variable name="className">
+                                                <xsl:call-template name="getDisplayClassNameForJava">
+                                                    <xsl:with-param name="packageName" select="$packageName"/>
+                                                    <xsl:with-param name="originalClassName" select="@name"/>
+                                                </xsl:call-template>
+                                            </xsl:variable>
+                                            <xsl:call-template name="generateClassElementByItemRefs">
+                                                <xsl:with-param name="itemRefs" select="$methodItemRefsUnderCurrentType"/>
+                                                <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                                                <xsl:with-param name="className" select="$className"/>
+                                                <xsl:with-param name="filePath" select="$filePath"/>
+                                            </xsl:call-template>
+                                        </xsl:for-each>
+                                    </xsl:when>
+                                    <xsl:otherwise>
+                                        <xsl:variable name="allItemRefsUnderCurrentFile" select="$cvgDataNode/Stats//Item/@itemRef"/>
+                                        <xsl:variable name="className">
+                                            <xsl:call-template name="getClassNameForDotNetAndCpp">
+                                                <xsl:with-param name="filePath" select="$filePath"/>
+                                            </xsl:call-template>
+                                        </xsl:variable>
+                                        <xsl:call-template name="generateClassElementByItemRefs">
+                                            <xsl:with-param name="itemRefs" select="$allItemRefsUnderCurrentFile"/>
+                                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                                            <xsl:with-param name="className" select="$className"/>
+                                            <xsl:with-param name="filePath" select="$filePath"/>
+                                        </xsl:call-template>
+                                    </xsl:otherwise>
+                                </xsl:choose>
+                            </xsl:for-each>
+                        </xsl:element>
+                    </xsl:element>
+                </xsl:if>
+            </xsl:for-each-group>
+        </xsl:element>
+    </xsl:template>
+
+    <xsl:template name="getLineRateForPackage">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesValid">
+            <xsl:call-template name="getCoverableLineNumber">
+                <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
+            </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$linesValid > 0">
+                <xsl:variable name="linesCovered">
+                    <xsl:call-template name="getCoveredLineNumber">
+                        <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:value-of select="$linesCovered div $linesValid"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="-1"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getCoverableLineNumber">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesValid" as="xs:integer*">
+            <xsl:for-each select="$locNodesToCalcute">
+                <xsl:variable name="lineNumbers" as="xs:string*">
+                    <xsl:variable name="locRefValue" select="@locRef"/>
+                    <xsl:variable name="statCvgElems" select="string-join(/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Static/StatCvg/@elems, ' ')"/>
+                    <xsl:sequence select="distinct-values(tokenize($statCvgElems, '\s+'))"/>
+                </xsl:variable>
+                <xsl:sequence select="count($lineNumbers)"/>
+            </xsl:for-each>
+        </xsl:variable>
+        <xsl:value-of select="sum($linesValid)"/>
+    </xsl:template>
+
+    <xsl:template name="getCoveredLineNumber">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesCovered" as="xs:integer*">
+            <xsl:for-each select="$locNodesToCalcute">
+                <xsl:variable name="coveredLineNumbers" as="xs:string*">
+                    <xsl:variable name="locRefValue" select="@locRef"/>
+                    <xsl:variable name="coveredLinesSeq" as="xs:string*">
+                        <xsl:for-each select="/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Dynamic//DynCvg">
+                            <xsl:sequence select="string(string-join(.//CtxCvg/@elemRefs, ' '))"/>
+                        </xsl:for-each>
+                    </xsl:variable>
+                    <xsl:sequence select="tokenize(string-join($coveredLinesSeq, ' '), '\s+')"/>
+                </xsl:variable>
+                <xsl:sequence select="count(distinct-values($coveredLineNumbers))"/>
+            </xsl:for-each>
+        </xsl:variable>
+        <xsl:value-of select="sum($linesCovered)"/>
+    </xsl:template>
+
+    <xsl:template name="getPackageName">
+        <xsl:param name="projectPath"/>
+        <xsl:variable name="delimiter" select="'/'"/>
+        <xsl:variable name="segments" select="tokenize($projectPath, '/')"/>
+        <xsl:choose>
+            <xsl:when test="count($segments) > 1">
+                <xsl:variable name="filename">
+                    <xsl:value-of select="$segments[last()]"/>
+                </xsl:variable>
+                <xsl:choose>
+                    <!--    Jtest    -->
+                    <xsl:when test="$toolName = 'jtest'">
+                        <xsl:variable name="packageNamePrefix">
+                            <xsl:call-template name="getPackageNamePrefix">
+                                <xsl:with-param name="projId" select="@projId"/>
+                            </xsl:call-template>
+                        </xsl:variable>
+                        <xsl:choose>
+                            <xsl:when test="contains($projectPath, translate($packageNamePrefix, '.', '/'))">
+                                <xsl:variable name="formattedResourceProjectPath" select="replace(substring-before($projectPath, concat($delimiter, $filename)), $delimiter, '.')"/>
+                                <xsl:value-of select="substring-after($formattedResourceProjectPath, substring-before($formattedResourceProjectPath, $packageNamePrefix))"/>
+                            </xsl:when>
+                            <xsl:otherwise>
+                                <xsl:value-of select="'&lt;default&gt;'"/>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:when>
+                    <!--     Dottest  or CPPTest std     -->
+                    <xsl:when test="$toolName = 'dottest' or $toolName = 'c++test'">
+                        <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                        <xsl:value-of select="replace(replace(substring-before($projectPath, concat($delimiter, $filename)), '%25', '%'), '%20', ' ')"/>
+                    </xsl:when>
+                </xsl:choose>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="'&lt;none&gt;'"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getPackageNamePrefix">
+        <xsl:param name="projId"/>
+        <xsl:choose>
+            <xsl:when test="contains($projId, ':')">
+                <xsl:value-of select="substring-before($projId, ':')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$projId"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getClassNameForDotNetAndCpp">
+        <xsl:param name="filePath"/>
+        <xsl:variable name="fileName" select="tokenize($filePath, '/')[last()]"/>
+        <xsl:value-of select="$fileName"/>
+    </xsl:template>
+
+    <xsl:template name="generateClassElementByItemRefs">
+        <!-- All itemRef from /CoverageData/CvgData/Stats/Item which belong to the current class -->
+        <xsl:param name="itemRefs"/>
+        <xsl:param name="cvgDataNode"/>
+        <xsl:param name="className"/>
+        <xsl:param name="filePath"/>
+
+        <!-- Generate string which contains unique line numbers of the current class (referenced by itemRefs) -->
+        <xsl:variable name="itemRefsString" select="concat(' ', string-join($itemRefs, ' '), ' ')"/>
+        <xsl:variable name="statCvgElems" select="$cvgDataNode/Static/StatCvg[contains($itemRefsString, concat(' ', @itemRef, ' '))]/@elems"/>
+        <xsl:variable name="statCvgElemsString" select="string-join($statCvgElems, ' ')"/>
+        <xsl:variable name="lineNumbers" select="distinct-values(tokenize($statCvgElemsString, '\s+'))"/>
+
+        <!-- This map is used to store unique line numbers. key: line number, value: covered times -->
+        <xsl:variable name="linesMap" as="map(xs:string, xs:integer)">
+            <xsl:map>
+                <xsl:for-each select="$lineNumbers">
+                    <xsl:variable name="lineCoveredTimes">
+                        <xsl:call-template name="getLineCoveredTimes">
+                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                            <xsl:with-param name="lineNumber" select="."/>
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:map-entry key="string(.)" select="xs:integer($lineCoveredTimes)"/>
+                </xsl:for-each>
+            </xsl:map>
+        </xsl:variable>
+
+        <xsl:variable name="verboseLineNumbers" select="tokenize($statCvgElemsString, '\s+')"/>
+        <xsl:variable name="statCvgHashes" select="$cvgDataNode/Static/StatCvg[contains($itemRefsString, concat(' ', @itemRef, ' '))]/@hashes"/>
+        <xsl:variable name="lineHashes" select="tokenize(string-join($statCvgHashes, ' '), '\s+')"/>
+
+        <!-- This variable is used to store the lineNumber(@elems) and lineHash(@hashes) pair according to the index -->
+        <xsl:variable name="lineHashPairs">
+            <xsl:for-each select="$verboseLineNumbers">
+                <xsl:variable name="index" select="position()"/>
+                <xsl:variable name="lineHash" select="$lineHashes[$index]"/>
+                <xsl:element name="lineHashPair">
+                    <xsl:attribute name="lineNumber" select="string(.)"/>
+                    <xsl:attribute name="lineHash" select="string($lineHash)" />
+                </xsl:element>
+            </xsl:for-each>
+        </xsl:variable>
+        <!-- This map is used to store unique line numbers and it's line hash. key: line number, value: line hash -->
+        <xsl:variable name="lineHashesMap" as="map(xs:string, xs:string)">
+            <xsl:map>
+                <xsl:for-each select="$lineNumbers">
+                    <xsl:variable name="line" select="."/>
+                    <xsl:variable name="lineHash" select="$lineHashPairs/lineHashPair[@lineNumber=$line]/@lineHash"/>
+                    <xsl:map-entry key="string(.)" select="string($lineHash[1])"/>
+                </xsl:for-each>
+            </xsl:map>
+        </xsl:variable>
+
+        <xsl:if test="count(map:keys($linesMap)) > 0">
+            <xsl:element name="class">
+                <xsl:attribute name="filename">
+                    <xsl:value-of select="$filePath"/>
+                </xsl:attribute>
+                <xsl:attribute name="name">
+                    <xsl:value-of select="$className"/>
+                </xsl:attribute>
+                <xsl:attribute name="line-rate">
+                    <!-- This map is used to store unique covered line numbers. key: covered line number, value: dummy value which is not used -->
+                    <xsl:variable name="coveredLinesMap" as="map(xs:string, xs:integer)">
+                        <xsl:map>
+                            <xsl:for-each select="map:keys($linesMap)">
+                                <xsl:variable name="lineNumber" select="."/>
+                                <xsl:variable name="lineCoveredTimes">
+                                    <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
+                                </xsl:variable>
+                                <xsl:if test="$lineCoveredTimes > 0">
+                                    <xsl:map-entry key="string(.)" select="1"/>
+                                </xsl:if>
+                            </xsl:for-each>
+                        </xsl:map>
+                    </xsl:variable>
+                    <!-- line-rate = # of coverable lines / # of covered line -->
+                    <xsl:value-of select="count(map:keys($coveredLinesMap)) div count(map:keys($linesMap))"/>
+                </xsl:attribute>
+                <xsl:element name="lines">
+                    <xsl:for-each select="map:keys($linesMap)">
+                        <xsl:sort data-type="number"/>
+                        <xsl:element name="line">
+                            <xsl:variable name="lineNumber" select="."/>
+                            <xsl:attribute name="number">
+                                <xsl:value-of select="$lineNumber"/>
+                            </xsl:attribute>
+                            <xsl:attribute name="hits">
+                                <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
+                            </xsl:attribute>
+                            <xsl:attribute name="hash">
+                                <xsl:value-of select="map:get($lineHashesMap, $lineNumber)"/>
+                            </xsl:attribute>
+                        </xsl:element>
+                    </xsl:for-each>
+                </xsl:element>
+            </xsl:element>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="getDisplayClassNameForJava">
+        <xsl:param name="packageName"/>
+        <xsl:param name="originalClassName"/>
+        <xsl:choose>
+            <xsl:when test="$packageName != '&lt;default&gt;'">
+                <xsl:value-of select="concat($packageName, '.', translate($originalClassName, '$', '#'))"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="translate($originalClassName, '$', '#')"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getLineCoveredTimes">
+        <xsl:param name="cvgDataNode"/>
+        <xsl:param name="lineNumber"/>
+        <!-- Leading and trailing spaces (' ') around the search string are included to avoid incorrect matches when using 'contains()' -->
+        <xsl:variable name="ctxCvgNodes" select="$cvgDataNode/Dynamic/DynCvg/CtxCvg[contains(concat(' ', @elemRefs, ' '), concat(' ', $lineNumber, ' '))]"/>
+        <xsl:value-of select="count(tokenize(string-join($ctxCvgNodes/@testRefs, ' '), '\s+'))"/>
+    </xsl:template>
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/xsl/cpptest-professional-xunit/README.md b/xsl/cpptest-professional-xunit/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4cc3a16c7f344f8a4f41d48836951f6c68590f3b
--- /dev/null
+++ b/xsl/cpptest-professional-xunit/README.md
@@ -0,0 +1,23 @@
+# Generating a xUnit report with C/C++test Professional
+
+To report unit tests results using xUnit format:
+
+1. Copy the [`xunit.xsl`](xunit.xsl) file into a local directory (`<CPPTEST_XSL_DIR>`).
+2. Copy [`Saxon`](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) files into a local directory (`<CPPTEST_SAXON_DIR>`).
+3. Update your GitLab pipeline to convert `<CPPTEST_REPORTS_DIR>/report.xml` report into `<CPPTEST_REPORTS_DIR>/report-xunit.xml`:
+
+```yaml
+    ...
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
+```
+4. Run your GitLab pipeline.
diff --git a/xsl/cpptest-professional-xunit/xunit.xsl b/xsl/cpptest-professional-xunit/xunit.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..50993c2f602711387187b3843e5bb192194dc355
--- /dev/null
+++ b/xsl/cpptest-professional-xunit/xunit.xsl
@@ -0,0 +1,590 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+    <xsl:output method="xml" encoding="UTF-8" indent="yes" />
+
+    <xsl:variable name="isLegacyMode" select="count(/ResultsSession/ExecutedTestsDetails) = 1"/>
+    <xsl:variable name="isFunctionalResult" select="/ResultsSession/@toolName = 'SOAtest'"/>
+    <xsl:variable name="useFullClassName" select="/ResultsSession/@toolName = 'C++test' or /ResultsSession/@toolId='c++test'" />
+
+    <xsl:param name="pipelineBuildWorkingDirectory"><xsl:value-of select="/ResultsSession/@pipelineBuildWorkingDirectory"/></xsl:param>
+
+    <xsl:template match="/">
+        <xsl:choose>
+            <xsl:when test="not($isLegacyMode = 'true') and not($isFunctionalResult = 'true')">
+                <!--  execution results 10.x  -->
+                <xsl:call-template name="processExecutionResults"/>
+            </xsl:when>
+            <xsl:when test="($isLegacyMode = 'true') and not($isFunctionalResult = 'true')">
+                <!--  execution results 9.x  -->
+                <xsl:call-template name="processLegacyExecutionResults" />
+            </xsl:when>
+            <xsl:when test="($isLegacyMode = 'true') and ($isFunctionalResult = 'true')">
+                <!--  functional results 9.x  -->
+            </xsl:when>
+            <xsl:when test="not($isLegacyMode = 'true') and ($isFunctionalResult = 'true')">
+                <!--  functional results 10.x  -->
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- =================  Execution results 10.x ================== -->
+
+    <xsl:template name="processExecutionResults">
+        <xsl:apply-templates select="/ResultsSession/Exec/ExecutedTestsDetails/Total" mode="exec" />
+    </xsl:template>
+
+    <xsl:template match="Total" mode="exec">
+        <testsuites>
+            <xsl:apply-templates select="Project/TestSuite | TestSuite" mode="exec" />
+        </testsuites>
+    </xsl:template>
+
+    <xsl:template match="TestSuite" mode="exec">
+        <xsl:choose>
+            <xsl:when test="parent::TestSuite">
+                <xsl:apply-templates select="Test" mode="exec" />
+                <xsl:apply-templates select="TestSuite" mode="exec"/>
+            </xsl:when>
+            <xsl:otherwise>
+
+                <testsuite name="{@name}" tests="{count(.//Test[not(TestCase)] | .//Test/TestCase)}" id="{position()}" package="">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addHostnameAttr"/>
+                    <xsl:call-template name="addTimestampAttr"/>
+                    <xsl:call-template name="addFailuresAttr"/>
+                    <xsl:call-template name="addErrorsAttr"/>
+                    <properties/>
+                    <xsl:apply-templates select="Test" mode="exec" />
+                    <xsl:apply-templates select="TestSuite" mode="exec" />
+                    <system-out/>
+                    <system-err/>
+                </testsuite>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="Test" mode="exec">
+        <xsl:choose>
+            <xsl:when test="TestCase">
+                <xsl:for-each select="TestCase">
+                    <xsl:call-template name="writeXUnitTestCase_Exec">
+                        <xsl:with-param name="id" select="@testId" />
+                        <xsl:with-param name="status" select="@status" />
+                        <xsl:with-param name="tcId" select="@id" />
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="writeXUnitTestCase_Exec">
+                    <xsl:with-param name="id" select="@id" />
+                    <xsl:with-param name="status" select="@status" />
+                    <xsl:with-param name="tcId" select="'null'" />
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="writeXUnitTestCase_Exec">
+        <xsl:param name="id" />
+        <xsl:param name="status" />
+        <xsl:param name="tcId" select="'null'" />
+
+        <xsl:variable name="className">
+            <xsl:call-template name="getClassname" />
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$tcId='null'">
+
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViols">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id]" />
+                            <xsl:with-param name="unitViols" select="/ResultsSession/Exec/ExecViols/UnitViol[@testId=$id]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:when>
+            <xsl:otherwise>
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViols">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id and @tcId=$tcId]" />
+                            <xsl:with-param name="unitViols" select="/ResultsSession/Exec/ExecViols/UnitViol[@testId=$id and @tcId=$tcId]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processExecViols">
+        <xsl:param name="execViols" />
+        <xsl:param name="unitViols" />
+        <xsl:param name="status" />
+
+        <xsl:choose>
+            <xsl:when test="$status='err'">
+                <error type="Error">
+                    <xsl:call-template name="printUnitViols">
+                        <xsl:with-param name="unitViols" select="$unitViols" />
+                    </xsl:call-template>
+                    <xsl:call-template name="printExecViols">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </error>
+            </xsl:when>
+            <xsl:when test="$status='fail'">
+                <failure type="Failure">
+                    <xsl:call-template name="printUnitViols">
+                        <xsl:with-param name="unitViols" select="$unitViols" />
+                    </xsl:call-template>
+                    <xsl:call-template name="printExecViols">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </failure>
+            </xsl:when>
+        </xsl:choose>
+
+    </xsl:template>
+
+    <xsl:template name="printUnitViols">
+        <xsl:param name="unitViols" />
+        <xsl:if test="count($unitViols) > 0">
+            <xsl:call-template name="processStackTrace">
+                <xsl:with-param name="unitViols" select="$unitViols" />
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="processStackTrace">
+        <xsl:param name="unitViols"/>
+        <xsl:for-each select="$unitViols/Thr/ThrPart">
+            <xsl:sort select="position()" data-type="number" order="descending" />
+            <xsl:if test="position() != '1'">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>Caused by: </xsl:text>
+            </xsl:if>
+            <xsl:value-of select="concat(@type,': ',@msg)" />
+
+            <xsl:for-each select="PathElem">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>at </xsl:text>
+                <xsl:value-of select="@desc" />
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="printExecViols">
+        <xsl:param name="execViols" />
+
+        <xsl:if test="count($execViols) > 0">
+            <xsl:choose>
+                <xsl:when test="count($execViols) > 1">
+                    <xsl:variable name="combinedFailures">
+                        <xsl:for-each select="$execViols">
+                            <xsl:if test="position() > 1 and string-length(@msg) > 0">
+                                <xsl:text>&#xa;&#x9;</xsl:text>
+                                <xsl:text>&#xa;&#x9;</xsl:text>
+                            </xsl:if>
+                            <xsl:value-of select="@msg" />
+                        </xsl:for-each>
+                    </xsl:variable>
+                    <xsl:attribute name="message">Multiple errors reported</xsl:attribute>
+                    <xsl:value-of select="$combinedFailures" />
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:attribute name="message"><xsl:value-of select="$execViols/@msg" /></xsl:attribute>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- =================  Execution results 9.x ================== -->
+
+    <xsl:template name="processLegacyExecutionResults">
+        <xsl:apply-templates select="/ResultsSession/ExecutedTestsDetails/Total" mode="execLegacy" />
+    </xsl:template>
+
+    <xsl:template match="Total" mode="execLegacy">
+        <testsuites>
+            <xsl:apply-templates select="Project/TestSuite | TestSuite" mode="execLegacy" />
+        </testsuites>
+    </xsl:template>
+
+    <xsl:template match="TestSuite" mode="execLegacy">
+        <xsl:choose>
+            <xsl:when test="parent::TestSuite">
+                <xsl:apply-templates select="Test" mode="execLegacy" />
+                <xsl:apply-templates select="TestSuite" mode="execLegacy"/>
+            </xsl:when>
+            <xsl:otherwise>
+
+                <testsuite name="{@name}" tests="{count(.//Test[not(TestCase)] | .//Test/TestCase)}"
+                           id="{position()}" package="">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addHostnameAttr"/>
+                    <xsl:call-template name="addTimestampAttr"/>
+                    <xsl:call-template name="addFailuresAttr"/>
+                    <xsl:call-template name="addErrorsAttr"/>
+                    <properties/>
+                    <xsl:apply-templates select="Test" mode="execLegacy" />
+                    <xsl:apply-templates select="TestSuite" mode="execLegacy" />
+                    <system-out/>
+                    <system-err/>
+                </testsuite>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getStatus">
+        <xsl:param name="testNode"/>
+
+        <xsl:if test="($testNode/@err) > 0">err</xsl:if>
+        <xsl:if test="not(($testNode/@err) > 0) and ($testNode/@fail) > 0">fail</xsl:if>
+        <xsl:if test="not(($testNode/@err) > 0) and not(($testNode/@fail) > 0) and ($testNode/@pass) > 0">pass</xsl:if>
+    </xsl:template>
+
+    <xsl:template match="Test" mode="execLegacy">
+        <xsl:choose>
+            <xsl:when test="TestCase">
+                <xsl:for-each select="TestCase">
+                    <xsl:variable name="status">
+                        <xsl:call-template name="getStatus">
+                            <xsl:with-param name="testNode" select="." />
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:call-template name="writeXUnitTestCase_ExecLegacy">
+                        <xsl:with-param name="id" select="@testId" />
+                        <xsl:with-param name="status" select="$status" />
+                        <xsl:with-param name="tcId" select="@id" />
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="status">
+                    <xsl:call-template name="getStatus">
+                        <xsl:with-param name="testNode" select="." />
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:call-template name="writeXUnitTestCase_ExecLegacy">
+                    <xsl:with-param name="id" select="@id" />
+                    <xsl:with-param name="status" select="$status" />
+                    <xsl:with-param name="tcId" select="'null'" />
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="writeXUnitTestCase_ExecLegacy">
+        <xsl:param name="id" />
+        <xsl:param name="status" />
+        <xsl:param name="tcId" select="'null'" />
+
+        <xsl:variable name="className">
+            <xsl:call-template name="getClassname" />
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$tcId='null'">
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViol_Legacy">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="testName" select="ancestor::Test[position()=1]/@name" />
+                <testcase name="{$testName}[{@params}]" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViol_Legacy">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id and @testCaseId=$tcId]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processExecViol_Legacy">
+        <xsl:param name="execViols" />
+        <xsl:param name="status" />
+        <xsl:choose>
+            <xsl:when test="$status='err'">
+                <error type="Error">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:call-template name="processStackTrace_Legacy">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </error>
+            </xsl:when>
+            <xsl:when test="$status='fail'">
+                <failure type="Failure">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:call-template name="processStackTrace_Legacy">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </failure>
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processStackTrace_Legacy">
+        <xsl:param name="execViols"/>
+        <xsl:for-each select="$execViols">
+            <xsl:sort select="@ln" />
+            <xsl:if test="position() > 1">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>&#xa;&#x9;</xsl:text>
+            </xsl:if>
+            <xsl:for-each select="./Thr/ThrPart">
+                <xsl:sort select="position()" data-type="number" order="descending" />
+                <xsl:if test="position() != '1'">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:text>Caused by: </xsl:text>
+                </xsl:if>
+                <xsl:value-of select="(@prnMsg)" />
+
+                <xsl:for-each select="Trace">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:text>at </xsl:text>
+                    <xsl:if test="string-length(@ln) > 0">
+                        <xsl:value-of select="concat(@fileName,':',@ln)" />
+                    </xsl:if>
+                    <xsl:if test="not(string-length(@ln) > 0)">
+                        <xsl:value-of select="(@fileName)" />
+                    </xsl:if>
+                </xsl:for-each>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- =================  Utilities ================== -->
+
+    <xsl:template name="addTimeAttr">
+        <xsl:choose>
+            <xsl:when test="string-length(@time) > 0">
+                <xsl:attribute name="time">
+                    <xsl:call-template name="timeFormat">
+                        <xsl:with-param name="initTime" select="@time" />
+                    </xsl:call-template>
+                </xsl:attribute>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:attribute name="time">
+                    <xsl:value-of select="0"/>
+                </xsl:attribute>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="timeFormat">
+        <xsl:param name="initTime" />
+
+        <xsl:variable name="millis">
+            <xsl:value-of select="substring($initTime,9,3)" />
+        </xsl:variable>
+
+        <xsl:variable name="sec">
+            <xsl:value-of select="substring($initTime,6,2)" />
+        </xsl:variable>
+
+        <xsl:variable name="min">
+            <xsl:value-of select="substring($initTime,3,2)" />
+        </xsl:variable>
+
+        <xsl:variable name="hour">
+            <xsl:value-of select="substring($initTime,1,1)" />
+        </xsl:variable>
+
+        <xsl:variable name="allSec">
+            <xsl:value-of select="$sec + (60 * $min) + (3600 * $hour)" />
+        </xsl:variable>
+
+        <xsl:value-of select="concat($allSec,'.',$millis)" />
+    </xsl:template>
+
+    <xsl:template name="addFileAttr">
+        <xsl:param name="tcId" select="'null'" />
+        <xsl:attribute name="file">
+            <!-- The structure "/ResultsSession/Scope/Locations/Loc" is available in the reports of JTest, DOTTest, SOATest, C++ Standard,
+                 then also in C++Test Professional reports starting from 2024.1 when using -property report.additional.report.dir=<additional_report_dir>.
+                 The value of the file attribute can only be found with this situation. -->
+            <xsl:if test="/ResultsSession/Scope/Locations/Loc">
+                <xsl:choose>
+                    <!-- When "TestCase" node does not exist, use "locRef" of the current "Test" node for the test. -->
+                    <xsl:when test="$tcId = 'null'">
+                        <xsl:apply-templates select="/ResultsSession/Scope/Locations/Loc">
+                            <xsl:with-param name="testLocRef" select="@locRef"/>
+                        </xsl:apply-templates>
+                    </xsl:when>
+                    <!-- When "TestCase" node exists, use "locRef" of the nearest "Test" ancestor of the current node for the test. -->
+                    <xsl:otherwise>
+                        <xsl:apply-templates select="/ResultsSession/Scope/Locations/Loc">
+                            <xsl:with-param name="testLocRef" select="ancestor::Test[position()=1]/@locRef"/>
+                        </xsl:apply-templates>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:if>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template match="Loc">
+        <xsl:param name="testLocRef"/>
+        <xsl:if test="$testLocRef = @locRef">
+            <xsl:variable name="uncodedPipelineBuildWorkingDirectory">
+                <xsl:if test="string($pipelineBuildWorkingDirectory) != ''">
+                    <xsl:value-of select="concat(translate($pipelineBuildWorkingDirectory, '\', '/'), '/')"/>
+                </xsl:if>
+            </xsl:variable>
+            <xsl:variable name="encodedPipelineBuildWorkingDirectory">
+                <xsl:if test="string($uncodedPipelineBuildWorkingDirectory) != ''">
+                    <!-- Replace % with %25 and space with %20 to get an encoded path-->
+                    <xsl:value-of select="replace(replace($uncodedPipelineBuildWorkingDirectory, '%', '%25'), ' ', '%20')"/>
+                </xsl:if>
+            </xsl:variable>
+            <xsl:variable name="processedPipelineBuildWorkingDirectory">
+                <xsl:choose>
+                    <xsl:when test="string($uncodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $uncodedPipelineBuildWorkingDirectory)">
+                        <xsl:value-of select="$uncodedPipelineBuildWorkingDirectory"/>
+                    </xsl:when>
+                    <!-- Using encoded pipeline build working directory when the uri attribute of <Loc> tag in Parasoft tool report(e.g. jtest report) is encoded -->
+                    <xsl:when test="string($encodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $encodedPipelineBuildWorkingDirectory)">
+                        <xsl:value-of select="$encodedPipelineBuildWorkingDirectory"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:value-of select="''"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:variable>
+            <xsl:variable name="isExternalReport" select="$processedPipelineBuildWorkingDirectory = ''"/>
+            <xsl:choose>
+                <xsl:when test="$isExternalReport">
+                    <xsl:value-of select="@uri"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <!-- Get relative source file path -->
+                    <xsl:value-of select="concat('./', substring-after(@uri, $processedPipelineBuildWorkingDirectory))"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="getClassname">
+        <xsl:choose>
+            <xsl:when test="$useFullClassName">
+                <xsl:call-template name="getFullClassName">
+                    <xsl:with-param name="currentNode"
+                                    select="ancestor::TestSuite[position()=1]" />
+                    <xsl:with-param name="depth">0</xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="ancestor::TestSuite[position()=1]/@name" />
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getFullClassName">
+        <xsl:param name="currentNode" />
+        <xsl:param name="depth" />
+
+        <xsl:if
+                test="(name($currentNode) = 'TestSuite' or name($currentNode) = 'Project')">
+            <xsl:call-template name="getFullClassName">
+                <xsl:with-param name="currentNode"
+                                select="$currentNode/.." />
+                <xsl:with-param name="depth" select="($depth) + 1" />
+            </xsl:call-template>
+
+            <xsl:value-of select="$currentNode/@name" />
+
+            <xsl:if test="$depth = 1">
+                <xsl:text>.</xsl:text>
+            </xsl:if>
+            <xsl:if test="$depth > 1">
+                <xsl:text>/</xsl:text>
+            </xsl:if>
+        </xsl:if>
+
+    </xsl:template>
+
+    <xsl:template name="addHostnameAttr">
+        <xsl:attribute name="hostname">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="/ResultsSession/@machine"/>
+                <xsl:with-param name="defaultValue">-</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addTimestampAttr">
+        <xsl:attribute name="timestamp">
+            <xsl:variable name="dateAntJunitFormat" select="substring(/ResultsSession/@time, 1, 19)"/>
+            <xsl:choose>
+                <xsl:when test="string-length($dateAntJunitFormat) = 19">
+                    <xsl:value-of select="$dateAntJunitFormat"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:value-of select="'1111-11-11T00:00:00'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addFailuresAttr">
+        <xsl:attribute name="failures">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="@fail"/>
+                <xsl:with-param name="defaultValue">0</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addErrorsAttr">
+        <xsl:attribute name="errors">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="@err"/>
+                <xsl:with-param name="defaultValue">0</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="getAttrValueOrDefault">
+        <xsl:param name="attr" />
+        <xsl:param name="defaultValue" />
+
+        <xsl:choose>
+            <xsl:when test="$attr != ''">
+                <xsl:value-of select="$attr"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$defaultValue"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/xsl/cpptest-standard-cobertura/README.md b/xsl/cpptest-standard-cobertura/README.md
index c80314c16a9f6f5315ad76f37f4911851c694d7d..fc79db3342868346c0e88dabc3f818005da8d6a0 100644
--- a/xsl/cpptest-standard-cobertura/README.md
+++ b/xsl/cpptest-standard-cobertura/README.md
@@ -8,23 +8,22 @@ To report Code Coverage results using Cobertura format:
 
 ```yaml
     ...
-    # Converts a coverage report to Cobertura format.
+    # Converts the coverage report to Cobertura format.
     #
     # To use Saxon for report transformation, a Java executable is required. 
-    # C/C++test includes Java which can be used for this purpose:
-    #   <CPPTEST_INSTALL_DIR>/bin/jre/bin/java
+    # C/C++test includes Java which can be used for this purpose.
     #
     # When running on Windows, be sure to replace backslashes:
     #   - $CI_PROJECT_DIR = $CI_PROJECT_DIR.Replace("\", "/")
     - echo "Generating Cobertura report..."
-    - java -jar "<CPPTEST_SAXON_DIR>/saxon-he-12.2.jar" -xsl:"<CPPTEST_XSL_DIR>/cobertura.xsl" -s:"<CPPTEST_REPORTS_DIR>/coverage.xml" -o:"<CPPTEST_REPORTS_DIR>/cobertura.xml" -t pipelineBuildWorkingDirectory=$CI_PROJECT_DIR
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/cobertura.xsl" -s:"$CPPTEST_REPORTS_DIR/coverage.xml" -o:"$CPPTEST_REPORTS_DIR/cobertura.xml" -t pipelineBuildWorkingDirectory=$CI_PROJECT_DIR
 
   artifacts:
     # Uploads code coverage results in the Cobertura format, so that they are displayed in GitLab.
     reports:
       coverage_report:
         coverage_format: cobertura
-        path: <CPPTEST_REPORTS_DIR>/cobertura.xml
+        path: $CPPTEST_REPORTS_DIR/cobertura.xml
     ...
 ```
 4. Run your GitLab pipeline.
diff --git a/xsl/cpptest-standard-cobertura/cobertura.xsl b/xsl/cpptest-standard-cobertura/cobertura.xsl
index da2414aad9012218341ecf6071df8812abcfb33a..086b5f84452b374935c2418ea24c0810c429cb8f 100644
--- a/xsl/cpptest-standard-cobertura/cobertura.xsl
+++ b/xsl/cpptest-standard-cobertura/cobertura.xsl
@@ -1,362 +1,451 @@
-<?xml version="1.0" encoding="UTF-8"  standalone="yes"?>
-<xsl:stylesheet version="3.0"
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:map="http://www.w3.org/2005/xpath-functions/map">
-    <xsl:variable name="toolName" select="/Coverage/@toolId"/>
-    <xsl:variable name="toolVer" select="/Coverage/@toolVer"/>
-    <xsl:variable name="toolDispName" select="/Coverage/@toolDispName"/>
-    <xsl:param name="pipelineBuildWorkingDirectory"><xsl:value-of select="/Coverage/@pipelineBuildWorkingDirectory"/></xsl:param>
-    <xsl:template match="/">
-        <xsl:element name="coverage">
-            <xsl:variable name="allLocNodes" select="/Coverage/Locations/Loc"/>
-            <xsl:variable name="linesValid">
-                <xsl:call-template name="getCoverableLineNumber">
-                    <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
-                </xsl:call-template>
-            </xsl:variable>
-            <xsl:if test="$linesValid > 0">
-                <xsl:variable name="linesCovered">
-                    <xsl:call-template name="getCoveredLineNumber">
-                        <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
-                    </xsl:call-template>
-                </xsl:variable>
-                <xsl:attribute name="line-rate">
-                    <xsl:value-of select="$linesCovered div $linesValid"/>
-                </xsl:attribute>
-                <xsl:attribute name="lines-covered">
-                    <xsl:value-of select="$linesCovered"/>
-                </xsl:attribute>
-                <xsl:attribute name="lines-valid">
-                    <xsl:value-of select="$linesValid"/>
-                </xsl:attribute>
-                <xsl:attribute name="version">
-                    <xsl:value-of select="$toolDispName"/><xsl:text> </xsl:text><xsl:value-of select="$toolVer"/>
-                </xsl:attribute>
-                <xsl:call-template name="packages"/>
-            </xsl:if>
-        </xsl:element>
-    </xsl:template>
-
-    <xsl:template name="packages">
-        <xsl:element name="packages">
-<!--             Group by the parent path of uri-->
-            <xsl:for-each-group select="/Coverage/Locations/Loc" group-by="substring-before(@uri, tokenize(@uri, '/')[last()])">
-                <xsl:variable name="lineRateForPacakgeTag">
-                    <xsl:call-template name="getLineRateForPackage">
-                        <xsl:with-param name="locNodesToCalcute" select="current-group()"/>
-                    </xsl:call-template>
-                </xsl:variable>
-                <xsl:if test="$lineRateForPacakgeTag != -1">
-                    <xsl:element name="package">
-                        <xsl:variable name="uncodedPipelineBuildWorkingDirectory">
-                            <xsl:if test="string($pipelineBuildWorkingDirectory) != ''">
-                                <xsl:value-of select="concat(translate($pipelineBuildWorkingDirectory, '\', '/'), '/')"/>
-                            </xsl:if>
-                        </xsl:variable>
-                        <xsl:variable name="encodedPipelineBuildWorkingDirectory">
-                             <xsl:if test="string($uncodedPipelineBuildWorkingDirectory) != ''">
-                                <!-- Replace % to %25 and space to %20 to get an encoded path-->
-                                <xsl:value-of select="replace(replace($uncodedPipelineBuildWorkingDirectory, '%', '%25'), ' ', '%20')"/>
-                            </xsl:if>
-                        </xsl:variable>
-                        <xsl:variable name="processedPipelineBuildWorkingDirectory">
-                            <xsl:choose>
-                                <xsl:when test="string($uncodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $uncodedPipelineBuildWorkingDirectory)">
-                                    <xsl:value-of select="$uncodedPipelineBuildWorkingDirectory"/>
-                                </xsl:when>
-                                <!-- Using encoded pipeline build working directory when the uri arrtibute of <Loc> tag in Parasoft tool report(e.g. jtest report) is encoded -->
-                                <xsl:when test="string($encodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $encodedPipelineBuildWorkingDirectory)">
-                                    <xsl:value-of select="$encodedPipelineBuildWorkingDirectory"/>
-                                </xsl:when>
-                                <xsl:otherwise>
-                                    <xsl:value-of select="''"/>
-                                </xsl:otherwise>
-                            </xsl:choose>
-                        </xsl:variable>
-                        <xsl:variable name="isExternalReport" select="$processedPipelineBuildWorkingDirectory = ''"/>
-                        <xsl:variable name="packageName">
-                            <xsl:choose>
-                                <xsl:when test="$isExternalReport">
-                                    <xsl:call-template name="getPackageName">
-                                        <xsl:with-param name="projectPath" select="@uri"/>
-                                    </xsl:call-template>
-                                </xsl:when>
-                                <xsl:otherwise>
-                                    <xsl:call-template name="getPackageName">
-                                        <!-- Get relative source file path -->
-                                        <xsl:with-param name="projectPath" select="substring-after(@uri, $processedPipelineBuildWorkingDirectory)"/>
-                                    </xsl:call-template>
-                                </xsl:otherwise>
-                            </xsl:choose>
-                        </xsl:variable>
-                        <xsl:attribute name="name">
-                            <xsl:value-of select="$packageName"/>
-                        </xsl:attribute>
-                        <xsl:attribute name="line-rate">
-                            <xsl:value-of select="$lineRateForPacakgeTag"/>
-                        </xsl:attribute>
-                        <xsl:element name="classes">
-                            <xsl:for-each select="current-group()">
-                                <xsl:variable name="filePath">
-                                    <xsl:choose>
-                                        <xsl:when test="$isExternalReport">
-                                            <xsl:value-of select="@uri"/>
-                                        </xsl:when>
-                                        <xsl:otherwise>
-                                           <!-- Get relative source file path -->
-                                           <xsl:value-of select="substring-after(@uri, $processedPipelineBuildWorkingDirectory)"/>
-                                        </xsl:otherwise>
-                                    </xsl:choose>
-                                </xsl:variable>
-                                <xsl:variable name="locRef" select="@locRef"/>
-                                <xsl:variable name="cvgDataNode" select="//CvgData[@locRef=$locRef]"/>
-                                <xsl:choose>
-                                    <xsl:when test="$toolName = 'jtest'">
-                                        <xsl:variable name="typeItemNodes" select="$cvgDataNode/Stats//Item[has-children()]"/>
-                                        <xsl:for-each select="$typeItemNodes">
-                                            <xsl:variable name="methodItemRefsUnderCurrentType" select="./Item[not(has-children())]/@itemRef"/>
-                                            <xsl:variable name="className">
-                                                <xsl:call-template name="getDisplayClassNameForJava">
-                                                    <xsl:with-param name="packageName" select="$packageName"/>
-                                                    <xsl:with-param name="originalClassName" select="@name"/>
-                                                </xsl:call-template>
-                                            </xsl:variable>
-                                            <xsl:call-template name="generateClassElementByItemRefs">
-                                                <xsl:with-param name="itemRefs" select="$methodItemRefsUnderCurrentType"/>
-                                                <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
-                                                <xsl:with-param name="className" select="$className"/>
-                                                <xsl:with-param name="filePath" select="$filePath"/>
-                                            </xsl:call-template>
-                                        </xsl:for-each>
-                                    </xsl:when>
-                                    <xsl:otherwise>
-                                        <xsl:variable name="allItemRefsUnderCurrentFile" select="$cvgDataNode/Stats//Item/@itemRef"/>
-                                        <xsl:variable name="className">
-                                            <xsl:call-template name="getClassNameForDotNetAndCpp">
-                                                <xsl:with-param name="filePath" select="$filePath"/>
-                                            </xsl:call-template>
-                                        </xsl:variable>
-                                        <xsl:call-template name="generateClassElementByItemRefs">
-                                            <xsl:with-param name="itemRefs" select="$allItemRefsUnderCurrentFile"/>
-                                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
-                                            <xsl:with-param name="className" select="$className"/>
-                                            <xsl:with-param name="filePath" select="$filePath"/>
-                                        </xsl:call-template>
-                                    </xsl:otherwise>
-                                </xsl:choose>
-                            </xsl:for-each>
-                        </xsl:element>
-                    </xsl:element>
-                </xsl:if>
-            </xsl:for-each-group>
-        </xsl:element>
-    </xsl:template>
-
-    <xsl:template name="getLineRateForPackage">
-        <xsl:param name="locNodesToCalcute"/>
-        <xsl:variable name="linesValid">
-            <xsl:call-template name="getCoverableLineNumber">
-                <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
-            </xsl:call-template>
-        </xsl:variable>
-
-        <xsl:choose>
-            <xsl:when test="$linesValid > 0">
-                <xsl:variable name="linesCovered">
-                    <xsl:call-template name="getCoveredLineNumber">
-                        <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
-                    </xsl:call-template>
-                </xsl:variable>
-                <xsl:value-of select="$linesCovered div $linesValid"/>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:value-of select="-1"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:template>
-
-    <xsl:template name="getCoverableLineNumber">
-        <xsl:param name="locNodesToCalcute"/>
-        <xsl:variable name="linesValid" as="xs:integer*">
-            <xsl:for-each select="$locNodesToCalcute">
-                <xsl:variable name="lineNumbers" as="xs:string*">
-                    <xsl:variable name="locRefValue" select="@locRef"/>
-                    <xsl:variable name="statCvgElems" select="string-join(/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Static/StatCvg/@elems, ' ')"/>
-                    <xsl:sequence select="distinct-values(tokenize($statCvgElems, '\s+'))"/>
-                </xsl:variable>
-                <xsl:sequence select="count($lineNumbers)"/>
-            </xsl:for-each>
-        </xsl:variable>
-        <xsl:value-of select="sum($linesValid)"/>
-    </xsl:template>
-
-    <xsl:template name="getCoveredLineNumber">
-        <xsl:param name="locNodesToCalcute"/>
-        <xsl:variable name="linesCovered" as="xs:integer*">
-            <xsl:for-each select="$locNodesToCalcute">
-                <xsl:variable name="coveredLineNumbers" as="xs:string*">
-                    <xsl:variable name="locRefValue" select="@locRef"/>
-                    <xsl:variable name="coveredLinesSeq" as="xs:string*">
-                        <xsl:for-each select="/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Dynamic//DynCvg">
-                            <xsl:sequence select="string(string-join(.//CtxCvg/@elemRefs, ' '))"/>
-                        </xsl:for-each>
-                    </xsl:variable>
-                    <xsl:sequence select="tokenize(string-join($coveredLinesSeq, ' '), '\s+')"/>
-                </xsl:variable>
-                <xsl:sequence select="count(distinct-values($coveredLineNumbers))"/>
-            </xsl:for-each>
-        </xsl:variable>
-        <xsl:value-of select="sum($linesCovered)"/>
-    </xsl:template>
-
-    <xsl:template name="getPackageName">
-        <xsl:param name="projectPath"/>
-        <xsl:variable name="delimiter" select="'/'"/>
-        <xsl:variable name="segments" select="tokenize($projectPath, '/')"/>
-        <xsl:choose>
-            <xsl:when test="count($segments) > 1">
-                <xsl:variable name="filename">
-                     <xsl:value-of select="$segments[last()]"/>
-                </xsl:variable>
-                <xsl:choose>
-                    <!--    Jtest    -->
-                    <xsl:when test="$toolName = 'jtest'">
-                        <xsl:variable name="packageNamePrefix">
-                            <xsl:call-template name="getPackageNamePrefix">
-                                <xsl:with-param name="projId" select="@projId"/>
-                            </xsl:call-template>
-                        </xsl:variable>
-                        <xsl:choose>
-                            <xsl:when test="contains($projectPath, translate($packageNamePrefix, '.', '/'))">
-                                <xsl:variable name="formattedResourceProjectPath" select="replace(substring-before($projectPath, concat($delimiter, $filename)), $delimiter, '.')"/>
-                                <xsl:value-of select="substring-after($formattedResourceProjectPath, substring-before($formattedResourceProjectPath, $packageNamePrefix))"/>
-                            </xsl:when>
-                            <xsl:otherwise>
-                                <xsl:value-of select="'&lt;default&gt;'"/>
-                            </xsl:otherwise>
-                        </xsl:choose>
-                    </xsl:when>
-                    <!--     Dottest  or CPPTest std     -->
-                    <xsl:when test="$toolName = 'dottest' or $toolName = 'c++test'">
-                        <xsl:value-of select="substring-before($projectPath, concat($delimiter, $filename))"/>
-                    </xsl:when>
-                </xsl:choose>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:value-of select="'&lt;none&gt;'"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:template>
-
-    <xsl:template name="getPackageNamePrefix">
-        <xsl:param name="projId"/>
-        <xsl:choose>
-            <xsl:when test="contains($projId, ':')">
-                <xsl:value-of select="substring-before($projId, ':')"/>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:value-of select="$projId"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:template>
-
-    <xsl:template name="getClassNameForDotNetAndCpp">
-        <xsl:param name="filePath"/>
-        <xsl:variable name="fileName" select="tokenize($filePath, '/')[last()]"/>
-        <xsl:value-of select="$fileName"/>
-    </xsl:template>
-
-    <xsl:template name="generateClassElementByItemRefs">
-        <!-- All itemRef from /CoverageData/CvgData/Stats/Item which belong to current class -->
-        <xsl:param name="itemRefs"/>
-        <xsl:param name="cvgDataNode"/>
-        <xsl:param name="className"/>
-        <xsl:param name="filePath"/>
-
-        <!-- Generate string which contains unique line numbers of the current class(referenced by itemRefs) -->
-        <xsl:variable name="itemRefsString" select="concat(' ', string-join($itemRefs, ' '), ' ')"/>
-        <xsl:variable name="statCvgElems" select="$cvgDataNode/Static/StatCvg[contains($itemRefsString, concat(' ', @itemRef, ' '))]/@elems"/>
-        <xsl:variable name="statCvgElemsString" select="string-join($statCvgElems, ' ')"/>
-        <xsl:variable name="lineNumbers" select="distinct-values(tokenize($statCvgElemsString, '\s+'))"/>
-
-        <!-- This map is used to store unique line numbers. key: line number, value: coverd times -->
-        <xsl:variable name="linesMap" as="map(xs:string, xs:integer)">
-            <xsl:map>
-                <xsl:for-each select="$lineNumbers">
-                    <xsl:variable name="lineCoveredTimes">
-                        <xsl:call-template name="getLineCoveredTimes">
-                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
-                            <xsl:with-param name="lineNumber" select="."/>
-                        </xsl:call-template>
-                    </xsl:variable>
-                    <xsl:map-entry key="string(.)" select="xs:integer($lineCoveredTimes)"/>
-                </xsl:for-each>
-            </xsl:map>
-        </xsl:variable>
-
-        <xsl:if test="count(map:keys($linesMap)) > 0">
-            <xsl:element name="class">
-                <xsl:attribute name="filename">
-                    <xsl:value-of select="$filePath"/>
-                </xsl:attribute>
-                <xsl:attribute name="name">
-                    <xsl:value-of select="$className"/>
-                </xsl:attribute>
-                <xsl:attribute name="line-rate">
-                    <!-- This map is used to store unique covered line numbers. key: covered line number, value: dummy value which is not used -->
-                    <xsl:variable name="coveredLinesMap" as="map(xs:string, xs:integer)">
-                        <xsl:map>
-                            <xsl:for-each select="map:keys($linesMap)">
-                                <xsl:variable name="lineNumber" select="."/>
-                                <xsl:variable name="lineCoveredTimes">
-                                    <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
-                                </xsl:variable>
-                                <xsl:if test="$lineCoveredTimes > 0">
-                                    <xsl:map-entry key="string(.)" select="1"/>
-                                </xsl:if>
-                            </xsl:for-each>
-                        </xsl:map>
-                    </xsl:variable>
-                    <!-- line-rate = # of coverable lines / # of covered line -->
-                    <xsl:value-of select="count(map:keys($coveredLinesMap)) div count(map:keys($linesMap))"/>
-                </xsl:attribute>
-                <xsl:element name="lines">
-                    <xsl:for-each select="map:keys($linesMap)">
-                        <xsl:sort data-type="number"/>
-                        <xsl:element name="line">
-                            <xsl:variable name="lineNumber" select="."/>
-                            <xsl:attribute name="number">
-                                <xsl:value-of select="$lineNumber"/>
-                            </xsl:attribute>
-                            <xsl:attribute name="hits">
-                                <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
-                            </xsl:attribute>
-                        </xsl:element>
-                    </xsl:for-each>
-                </xsl:element>
-            </xsl:element>
-        </xsl:if>
-    </xsl:template>
-
-    <xsl:template name="getDisplayClassNameForJava">
-        <xsl:param name="packageName"/>
-        <xsl:param name="originalClassName"/>
-        <xsl:choose>
-            <xsl:when test="$packageName != '&lt;default&gt;'">
-                <xsl:value-of select="concat($packageName, '.', translate($originalClassName, '$', '#'))"/>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:value-of select="translate($originalClassName, '$', '#')"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:template>
-
-    <xsl:template name="getLineCoveredTimes">
-        <xsl:param name="cvgDataNode"/>
-        <xsl:param name="lineNumber"/>
-        <!-- Leading and trailing space (' ') around the search string are included to avoid incorrect matches when using 'contains()' -->
-        <xsl:variable name="ctxCvgNodes" select="$cvgDataNode/Dynamic/DynCvg/CtxCvg[contains(concat(' ', @elemRefs, ' '), concat(' ', $lineNumber, ' '))]"/>
-        <xsl:value-of select="count(tokenize(string-join($ctxCvgNodes/@testRefs, ' '), '\s+'))"/>
-    </xsl:template>
+<?xml version="1.0" encoding="UTF-8"  standalone="yes"?>
+<xsl:stylesheet version="3.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                xmlns:map="http://www.w3.org/2005/xpath-functions/map">
+    <xsl:variable name="toolName" select="/Coverage/@toolId"/>
+    <xsl:variable name="toolVer" select="/Coverage/@toolVer"/>
+    <xsl:variable name="toolDispName" select="/Coverage/@toolDispName"/>
+    <xsl:param name="pipelineBuildWorkingDirectory"><xsl:value-of select="/Coverage/@pipelineBuildWorkingDirectory"/></xsl:param>
+
+    <xsl:template name="getUriWithoutFilePrefix">
+        <xsl:param name="rawUri"/>
+        <xsl:choose>
+            <!-- for file:///xxx uri pattern -->
+            <xsl:when test="matches($rawUri, '^file:///([^/\\]+)')">
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, 'file:///')"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- for file://hostname/xxx uri pattern -->
+            <xsl:when test="matches($rawUri, '^file://([^/]+)/([^/\\]+)')">
+                <!-- Extract the hostname from an uri, like: the result is 'hostname' for uri 'file://hostname/C:/abc' -->
+                <xsl:variable name="hostname" select="replace($rawUri, '^file://([^/]+)(/.*)$', '$1')" />
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, concat('file://', $hostname , '/'))"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <!-- for file:/ uri pattern -->
+            <xsl:when test="matches($rawUri, '^file:/([^/\\]+)')">
+                <xsl:variable name="uriWithoutFilePrefix" select="substring-after($rawUri, 'file:/')"/>
+                <xsl:call-template name="makeUriSystemCompatible">
+                    <xsl:with-param name="uriWithoutFilePrefix" select="$uriWithoutFilePrefix"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$rawUri"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="makeUriSystemCompatible">
+        <xsl:param name="uriWithoutFilePrefix"/>
+        <xsl:choose>
+            <!-- on windows: start with X:/ or X:\ -->
+            <xsl:when test="matches($uriWithoutFilePrefix, '^[A-Za-z]:[/\\]')">
+                <xsl:value-of select="$uriWithoutFilePrefix"/>
+            </xsl:when>
+            <!-- on linux -->
+            <xsl:otherwise>
+                <xsl:value-of select="concat('/', $uriWithoutFilePrefix)"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="/">
+        <xsl:element name="coverage">
+            <xsl:variable name="allLocNodes" select="/Coverage/Locations/Loc"/>
+            <xsl:variable name="linesValid">
+                <xsl:call-template name="getCoverableLineNumber">
+                    <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
+                </xsl:call-template>
+            </xsl:variable>
+            <xsl:if test="$linesValid > 0">
+                <xsl:variable name="linesCovered">
+                    <xsl:call-template name="getCoveredLineNumber">
+                        <xsl:with-param name="locNodesToCalcute" select="$allLocNodes"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:attribute name="line-rate">
+                    <xsl:value-of select="$linesCovered div $linesValid"/>
+                </xsl:attribute>
+                <xsl:attribute name="lines-covered">
+                    <xsl:value-of select="$linesCovered"/>
+                </xsl:attribute>
+                <xsl:attribute name="lines-valid">
+                    <xsl:value-of select="$linesValid"/>
+                </xsl:attribute>
+                <xsl:attribute name="version">
+                    <xsl:value-of select="$toolDispName"/><xsl:text> </xsl:text><xsl:value-of select="$toolVer"/>
+                </xsl:attribute>
+                <xsl:call-template name="packages"/>
+            </xsl:if>
+        </xsl:element>
+    </xsl:template>
+
+    <xsl:template name="packages">
+        <xsl:element name="packages">
+            <!-- Group by the parent path of uri-->
+            <xsl:for-each-group select="/Coverage/Locations/Loc" group-by="substring-before(@uri, tokenize(@uri, '/')[last()])">
+                <xsl:variable name="theFirstUriWithoutFilePrefixInCurrentGroup">
+                    <xsl:call-template name="getUriWithoutFilePrefix">
+                        <xsl:with-param name="rawUri" select="@uri"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:variable name="lineRateForPacakgeTag">
+                    <xsl:call-template name="getLineRateForPackage">
+                        <xsl:with-param name="locNodesToCalcute" select="current-group()"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:if test="$lineRateForPacakgeTag != -1">
+                    <xsl:element name="package">
+                        <xsl:variable name="uncodedPipelineBuildWorkingDirectory">
+                            <xsl:if test="string($pipelineBuildWorkingDirectory) != ''">
+                                <xsl:value-of select="concat(translate($pipelineBuildWorkingDirectory, '\', '/'), '/')"/>
+                            </xsl:if>
+                        </xsl:variable>
+                        <xsl:variable name="encodedPipelineBuildWorkingDirectory">
+                            <xsl:if test="string($uncodedPipelineBuildWorkingDirectory) != ''">
+                                <!-- Replace % with %25 and space with %20 to get an encoded path-->
+                                <xsl:value-of select="replace(replace($uncodedPipelineBuildWorkingDirectory, '%', '%25'), ' ', '%20')"/>
+                            </xsl:if>
+                        </xsl:variable>
+                        <xsl:variable name="processedPipelineBuildWorkingDirectory">
+                            <xsl:choose>
+                                <xsl:when test="string($uncodedPipelineBuildWorkingDirectory) != '' and contains($theFirstUriWithoutFilePrefixInCurrentGroup, $uncodedPipelineBuildWorkingDirectory)">
+                                    <xsl:value-of select="$uncodedPipelineBuildWorkingDirectory"/>
+                                </xsl:when>
+                                <!-- Using encoded pipeline build working directory when the uri attribute of <Loc> tag in Parasoft tool report(e.g. jtest report) is encoded -->
+                                <xsl:when test="string($encodedPipelineBuildWorkingDirectory) != '' and contains($theFirstUriWithoutFilePrefixInCurrentGroup, $encodedPipelineBuildWorkingDirectory)">
+                                    <xsl:value-of select="$encodedPipelineBuildWorkingDirectory"/>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:value-of select="''"/>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:variable>
+                        <xsl:variable name="isExternalReport" select="$processedPipelineBuildWorkingDirectory = ''"/>
+                        <xsl:variable name="packageName">
+                            <xsl:choose>
+                                <xsl:when test="$isExternalReport">
+                                    <xsl:call-template name="getPackageName">
+                                        <xsl:with-param name="projectPath" select="$theFirstUriWithoutFilePrefixInCurrentGroup"/>
+                                    </xsl:call-template>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <xsl:call-template name="getPackageName">
+                                        <!-- Get relative source file path -->
+                                        <xsl:with-param name="projectPath" select="substring-after($theFirstUriWithoutFilePrefixInCurrentGroup, $processedPipelineBuildWorkingDirectory)"/>
+                                    </xsl:call-template>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:variable>
+                        <xsl:attribute name="name">
+                            <xsl:value-of select="$packageName"/>
+                        </xsl:attribute>
+                        <xsl:attribute name="line-rate">
+                            <xsl:value-of select="$lineRateForPacakgeTag"/>
+                        </xsl:attribute>
+                        <xsl:element name="classes">
+                            <xsl:for-each select="current-group()">
+                                <xsl:variable name="sourceFileUriWithoutFilePrefix">
+                                    <xsl:call-template name="getUriWithoutFilePrefix">
+                                        <xsl:with-param name="rawUri" select="@uri"/>
+                                    </xsl:call-template>
+                                </xsl:variable>
+                                <xsl:variable name="filePath">
+                                    <xsl:choose>
+                                        <xsl:when test="$isExternalReport">
+                                            <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                                            <xsl:value-of select="replace(replace($sourceFileUriWithoutFilePrefix, '%25', '%'), '%20', ' ')"/>
+                                        </xsl:when>
+                                        <xsl:otherwise>
+                                            <!-- Get relative source file path -->
+                                            <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                                            <xsl:value-of select="replace(replace(substring-after($sourceFileUriWithoutFilePrefix, $processedPipelineBuildWorkingDirectory), '%25', '%'), '%20', ' ')"/>
+                                        </xsl:otherwise>
+                                    </xsl:choose>
+                                </xsl:variable>
+                                <xsl:variable name="locRef" select="@locRef"/>
+                                <xsl:variable name="cvgDataNode" select="//CvgData[@locRef=$locRef]"/>
+                                <xsl:choose>
+                                    <xsl:when test="$toolName = 'jtest'">
+                                        <xsl:variable name="typeItemNodes" select="$cvgDataNode/Stats//Item[has-children()]"/>
+                                        <xsl:for-each select="$typeItemNodes">
+                                            <xsl:variable name="methodItemRefsUnderCurrentType" select="./Item[not(has-children())]/@itemRef"/>
+                                            <xsl:variable name="className">
+                                                <xsl:call-template name="getDisplayClassNameForJava">
+                                                    <xsl:with-param name="packageName" select="$packageName"/>
+                                                    <xsl:with-param name="originalClassName" select="@name"/>
+                                                </xsl:call-template>
+                                            </xsl:variable>
+                                            <xsl:call-template name="generateClassElementByItemRefs">
+                                                <xsl:with-param name="itemRefs" select="$methodItemRefsUnderCurrentType"/>
+                                                <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                                                <xsl:with-param name="className" select="$className"/>
+                                                <xsl:with-param name="filePath" select="$filePath"/>
+                                            </xsl:call-template>
+                                        </xsl:for-each>
+                                    </xsl:when>
+                                    <xsl:otherwise>
+                                        <xsl:variable name="allItemRefsUnderCurrentFile" select="$cvgDataNode/Stats//Item/@itemRef"/>
+                                        <xsl:variable name="className">
+                                            <xsl:call-template name="getClassNameForDotNetAndCpp">
+                                                <xsl:with-param name="filePath" select="$filePath"/>
+                                            </xsl:call-template>
+                                        </xsl:variable>
+                                        <xsl:call-template name="generateClassElementByItemRefs">
+                                            <xsl:with-param name="itemRefs" select="$allItemRefsUnderCurrentFile"/>
+                                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                                            <xsl:with-param name="className" select="$className"/>
+                                            <xsl:with-param name="filePath" select="$filePath"/>
+                                        </xsl:call-template>
+                                    </xsl:otherwise>
+                                </xsl:choose>
+                            </xsl:for-each>
+                        </xsl:element>
+                    </xsl:element>
+                </xsl:if>
+            </xsl:for-each-group>
+        </xsl:element>
+    </xsl:template>
+
+    <xsl:template name="getLineRateForPackage">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesValid">
+            <xsl:call-template name="getCoverableLineNumber">
+                <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
+            </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$linesValid > 0">
+                <xsl:variable name="linesCovered">
+                    <xsl:call-template name="getCoveredLineNumber">
+                        <xsl:with-param name="locNodesToCalcute" select="$locNodesToCalcute"/>
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:value-of select="$linesCovered div $linesValid"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="-1"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getCoverableLineNumber">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesValid" as="xs:integer*">
+            <xsl:for-each select="$locNodesToCalcute">
+                <xsl:variable name="lineNumbers" as="xs:string*">
+                    <xsl:variable name="locRefValue" select="@locRef"/>
+                    <xsl:variable name="statCvgElems" select="string-join(/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Static/StatCvg/@elems, ' ')"/>
+                    <xsl:sequence select="distinct-values(tokenize($statCvgElems, '\s+'))"/>
+                </xsl:variable>
+                <xsl:sequence select="count($lineNumbers)"/>
+            </xsl:for-each>
+        </xsl:variable>
+        <xsl:value-of select="sum($linesValid)"/>
+    </xsl:template>
+
+    <xsl:template name="getCoveredLineNumber">
+        <xsl:param name="locNodesToCalcute"/>
+        <xsl:variable name="linesCovered" as="xs:integer*">
+            <xsl:for-each select="$locNodesToCalcute">
+                <xsl:variable name="coveredLineNumbers" as="xs:string*">
+                    <xsl:variable name="locRefValue" select="@locRef"/>
+                    <xsl:variable name="coveredLinesSeq" as="xs:string*">
+                        <xsl:for-each select="/Coverage/CoverageData/CvgData[@locRef = $locRefValue]/Dynamic//DynCvg">
+                            <xsl:sequence select="string(string-join(.//CtxCvg/@elemRefs, ' '))"/>
+                        </xsl:for-each>
+                    </xsl:variable>
+                    <xsl:sequence select="tokenize(string-join($coveredLinesSeq, ' '), '\s+')"/>
+                </xsl:variable>
+                <xsl:sequence select="count(distinct-values($coveredLineNumbers))"/>
+            </xsl:for-each>
+        </xsl:variable>
+        <xsl:value-of select="sum($linesCovered)"/>
+    </xsl:template>
+
+    <xsl:template name="getPackageName">
+        <xsl:param name="projectPath"/>
+        <xsl:variable name="delimiter" select="'/'"/>
+        <xsl:variable name="segments" select="tokenize($projectPath, '/')"/>
+        <xsl:choose>
+            <xsl:when test="count($segments) > 1">
+                <xsl:variable name="filename">
+                    <xsl:value-of select="$segments[last()]"/>
+                </xsl:variable>
+                <xsl:choose>
+                    <!--    Jtest    -->
+                    <xsl:when test="$toolName = 'jtest'">
+                        <xsl:variable name="packageNamePrefix">
+                            <xsl:call-template name="getPackageNamePrefix">
+                                <xsl:with-param name="projId" select="@projId"/>
+                            </xsl:call-template>
+                        </xsl:variable>
+                        <xsl:choose>
+                            <xsl:when test="contains($projectPath, translate($packageNamePrefix, '.', '/'))">
+                                <xsl:variable name="formattedResourceProjectPath" select="replace(substring-before($projectPath, concat($delimiter, $filename)), $delimiter, '.')"/>
+                                <xsl:value-of select="substring-after($formattedResourceProjectPath, substring-before($formattedResourceProjectPath, $packageNamePrefix))"/>
+                            </xsl:when>
+                            <xsl:otherwise>
+                                <xsl:value-of select="'&lt;default&gt;'"/>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:when>
+                    <!--     Dottest  or CPPTest std     -->
+                    <xsl:when test="$toolName = 'dottest' or $toolName = 'c++test'">
+                        <!-- Replace %25 with % and %20 with space to get an uncoded path-->
+                        <xsl:value-of select="replace(replace(substring-before($projectPath, concat($delimiter, $filename)), '%25', '%'), '%20', ' ')"/>
+                    </xsl:when>
+                </xsl:choose>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="'&lt;none&gt;'"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getPackageNamePrefix">
+        <xsl:param name="projId"/>
+        <xsl:choose>
+            <xsl:when test="contains($projId, ':')">
+                <xsl:value-of select="substring-before($projId, ':')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$projId"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getClassNameForDotNetAndCpp">
+        <xsl:param name="filePath"/>
+        <xsl:variable name="fileName" select="tokenize($filePath, '/')[last()]"/>
+        <xsl:value-of select="$fileName"/>
+    </xsl:template>
+
+    <xsl:template name="generateClassElementByItemRefs">
+        <!-- All itemRef from /CoverageData/CvgData/Stats/Item which belong to the current class -->
+        <xsl:param name="itemRefs"/>
+        <xsl:param name="cvgDataNode"/>
+        <xsl:param name="className"/>
+        <xsl:param name="filePath"/>
+
+        <!-- Generate string which contains unique line numbers of the current class (referenced by itemRefs) -->
+        <xsl:variable name="itemRefsString" select="concat(' ', string-join($itemRefs, ' '), ' ')"/>
+        <xsl:variable name="statCvgElems" select="$cvgDataNode/Static/StatCvg[contains($itemRefsString, concat(' ', @itemRef, ' '))]/@elems"/>
+        <xsl:variable name="statCvgElemsString" select="string-join($statCvgElems, ' ')"/>
+        <xsl:variable name="lineNumbers" select="distinct-values(tokenize($statCvgElemsString, '\s+'))"/>
+
+        <!-- This map is used to store unique line numbers. key: line number, value: covered times -->
+        <xsl:variable name="linesMap" as="map(xs:string, xs:integer)">
+            <xsl:map>
+                <xsl:for-each select="$lineNumbers">
+                    <xsl:variable name="lineCoveredTimes">
+                        <xsl:call-template name="getLineCoveredTimes">
+                            <xsl:with-param name="cvgDataNode" select="$cvgDataNode"/>
+                            <xsl:with-param name="lineNumber" select="."/>
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:map-entry key="string(.)" select="xs:integer($lineCoveredTimes)"/>
+                </xsl:for-each>
+            </xsl:map>
+        </xsl:variable>
+
+        <xsl:variable name="verboseLineNumbers" select="tokenize($statCvgElemsString, '\s+')"/>
+        <xsl:variable name="statCvgHashes" select="$cvgDataNode/Static/StatCvg[contains($itemRefsString, concat(' ', @itemRef, ' '))]/@hashes"/>
+        <xsl:variable name="lineHashes" select="tokenize(string-join($statCvgHashes, ' '), '\s+')"/>
+
+        <!-- This variable is used to store the lineNumber(@elems) and lineHash(@hashes) pair according to the index -->
+        <xsl:variable name="lineHashPairs">
+            <xsl:for-each select="$verboseLineNumbers">
+                <xsl:variable name="index" select="position()"/>
+                <xsl:variable name="lineHash" select="$lineHashes[$index]"/>
+                <xsl:element name="lineHashPair">
+                    <xsl:attribute name="lineNumber" select="string(.)"/>
+                    <xsl:attribute name="lineHash" select="string($lineHash)" />
+                </xsl:element>
+            </xsl:for-each>
+        </xsl:variable>
+        <!-- This map is used to store unique line numbers and it's line hash. key: line number, value: line hash -->
+        <xsl:variable name="lineHashesMap" as="map(xs:string, xs:string)">
+            <xsl:map>
+                <xsl:for-each select="$lineNumbers">
+                    <xsl:variable name="line" select="."/>
+                    <xsl:variable name="lineHash" select="$lineHashPairs/lineHashPair[@lineNumber=$line]/@lineHash"/>
+                    <xsl:map-entry key="string(.)" select="string($lineHash[1])"/>
+                </xsl:for-each>
+            </xsl:map>
+        </xsl:variable>
+
+        <xsl:if test="count(map:keys($linesMap)) > 0">
+            <xsl:element name="class">
+                <xsl:attribute name="filename">
+                    <xsl:value-of select="$filePath"/>
+                </xsl:attribute>
+                <xsl:attribute name="name">
+                    <xsl:value-of select="$className"/>
+                </xsl:attribute>
+                <xsl:attribute name="line-rate">
+                    <!-- This map is used to store unique covered line numbers. key: covered line number, value: dummy value which is not used -->
+                    <xsl:variable name="coveredLinesMap" as="map(xs:string, xs:integer)">
+                        <xsl:map>
+                            <xsl:for-each select="map:keys($linesMap)">
+                                <xsl:variable name="lineNumber" select="."/>
+                                <xsl:variable name="lineCoveredTimes">
+                                    <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
+                                </xsl:variable>
+                                <xsl:if test="$lineCoveredTimes > 0">
+                                    <xsl:map-entry key="string(.)" select="1"/>
+                                </xsl:if>
+                            </xsl:for-each>
+                        </xsl:map>
+                    </xsl:variable>
+                    <!-- line-rate = # of coverable lines / # of covered line -->
+                    <xsl:value-of select="count(map:keys($coveredLinesMap)) div count(map:keys($linesMap))"/>
+                </xsl:attribute>
+                <xsl:element name="lines">
+                    <xsl:for-each select="map:keys($linesMap)">
+                        <xsl:sort data-type="number"/>
+                        <xsl:element name="line">
+                            <xsl:variable name="lineNumber" select="."/>
+                            <xsl:attribute name="number">
+                                <xsl:value-of select="$lineNumber"/>
+                            </xsl:attribute>
+                            <xsl:attribute name="hits">
+                                <xsl:value-of select="map:get($linesMap, $lineNumber)"/>
+                            </xsl:attribute>
+                            <xsl:attribute name="hash">
+                                <xsl:value-of select="map:get($lineHashesMap, $lineNumber)"/>
+                            </xsl:attribute>
+                        </xsl:element>
+                    </xsl:for-each>
+                </xsl:element>
+            </xsl:element>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="getDisplayClassNameForJava">
+        <xsl:param name="packageName"/>
+        <xsl:param name="originalClassName"/>
+        <xsl:choose>
+            <xsl:when test="$packageName != '&lt;default&gt;'">
+                <xsl:value-of select="concat($packageName, '.', translate($originalClassName, '$', '#'))"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="translate($originalClassName, '$', '#')"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getLineCoveredTimes">
+        <xsl:param name="cvgDataNode"/>
+        <xsl:param name="lineNumber"/>
+        <!-- Leading and trailing spaces (' ') around the search string are included to avoid incorrect matches when using 'contains()' -->
+        <xsl:variable name="ctxCvgNodes" select="$cvgDataNode/Dynamic/DynCvg/CtxCvg[contains(concat(' ', @elemRefs, ' '), concat(' ', $lineNumber, ' '))]"/>
+        <xsl:value-of select="count(tokenize(string-join($ctxCvgNodes/@testRefs, ' '), '\s+'))"/>
+    </xsl:template>
 </xsl:stylesheet>
\ No newline at end of file
diff --git a/xsl/cpptest-standard-xunit/README.md b/xsl/cpptest-standard-xunit/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1dd30127a46c426a8c3e3b52a675533d13086a71
--- /dev/null
+++ b/xsl/cpptest-standard-xunit/README.md
@@ -0,0 +1,23 @@
+# Generating a xUnit report with C/C++test Standard
+
+To report unit tests results using xUnit format:
+
+1. Copy the [`xunit.xsl`](xunit.xsl) file into a local directory (`<CPPTEST_XSL_DIR>`).
+2. Copy [`Saxon`](https://gitlab.com/parasoft/cpptest-gitlab/-/blob/master/xsl/saxon) files into a local directory (`<CPPTEST_SAXON_DIR>`).
+3. Update your GitLab pipeline to convert `<CPPTEST_REPORTS_DIR>/report.xml` report into `<CPPTEST_REPORTS_DIR>/report-xunit.xml`:
+
+```yaml
+    ...
+    # Converts the unit tests report to xUnit format.
+    #
+    # To use Saxon for report transformation, a Java executable is required.
+    # C/C++test includes Java which can be used for this purpose.
+    - echo "Generating xUnit report..."
+    - $CPPTEST_INSTALL_DIR/bin/jre/bin/java -jar "$CPPTEST_SAXON_DIR/saxon-he-12.2.jar" -xsl:"$CPPTEST_XSL_DIR/xunit.xsl" -s:"$CPPTEST_REPORTS_DIR/report.xml" -o:"$CPPTEST_REPORTS_DIR/report-xunit.xml"
+
+  artifacts:
+    # Uploads test results in the xUnit format, so that they are displayed in GitLab
+    reports:
+      junit: $CPPTEST_REPORTS_DIR/report-xunit.xml
+```
+4. Run your GitLab pipeline.
diff --git a/xsl/cpptest-standard-xunit/xunit.xsl b/xsl/cpptest-standard-xunit/xunit.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..50993c2f602711387187b3843e5bb192194dc355
--- /dev/null
+++ b/xsl/cpptest-standard-xunit/xunit.xsl
@@ -0,0 +1,590 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+    <xsl:output method="xml" encoding="UTF-8" indent="yes" />
+
+    <xsl:variable name="isLegacyMode" select="count(/ResultsSession/ExecutedTestsDetails) = 1"/>
+    <xsl:variable name="isFunctionalResult" select="/ResultsSession/@toolName = 'SOAtest'"/>
+    <xsl:variable name="useFullClassName" select="/ResultsSession/@toolName = 'C++test' or /ResultsSession/@toolId='c++test'" />
+
+    <xsl:param name="pipelineBuildWorkingDirectory"><xsl:value-of select="/ResultsSession/@pipelineBuildWorkingDirectory"/></xsl:param>
+
+    <xsl:template match="/">
+        <xsl:choose>
+            <xsl:when test="not($isLegacyMode = 'true') and not($isFunctionalResult = 'true')">
+                <!--  execution results 10.x  -->
+                <xsl:call-template name="processExecutionResults"/>
+            </xsl:when>
+            <xsl:when test="($isLegacyMode = 'true') and not($isFunctionalResult = 'true')">
+                <!--  execution results 9.x  -->
+                <xsl:call-template name="processLegacyExecutionResults" />
+            </xsl:when>
+            <xsl:when test="($isLegacyMode = 'true') and ($isFunctionalResult = 'true')">
+                <!--  functional results 9.x  -->
+            </xsl:when>
+            <xsl:when test="not($isLegacyMode = 'true') and ($isFunctionalResult = 'true')">
+                <!--  functional results 10.x  -->
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- =================  Execution results 10.x ================== -->
+
+    <xsl:template name="processExecutionResults">
+        <xsl:apply-templates select="/ResultsSession/Exec/ExecutedTestsDetails/Total" mode="exec" />
+    </xsl:template>
+
+    <xsl:template match="Total" mode="exec">
+        <testsuites>
+            <xsl:apply-templates select="Project/TestSuite | TestSuite" mode="exec" />
+        </testsuites>
+    </xsl:template>
+
+    <xsl:template match="TestSuite" mode="exec">
+        <xsl:choose>
+            <xsl:when test="parent::TestSuite">
+                <xsl:apply-templates select="Test" mode="exec" />
+                <xsl:apply-templates select="TestSuite" mode="exec"/>
+            </xsl:when>
+            <xsl:otherwise>
+
+                <testsuite name="{@name}" tests="{count(.//Test[not(TestCase)] | .//Test/TestCase)}" id="{position()}" package="">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addHostnameAttr"/>
+                    <xsl:call-template name="addTimestampAttr"/>
+                    <xsl:call-template name="addFailuresAttr"/>
+                    <xsl:call-template name="addErrorsAttr"/>
+                    <properties/>
+                    <xsl:apply-templates select="Test" mode="exec" />
+                    <xsl:apply-templates select="TestSuite" mode="exec" />
+                    <system-out/>
+                    <system-err/>
+                </testsuite>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="Test" mode="exec">
+        <xsl:choose>
+            <xsl:when test="TestCase">
+                <xsl:for-each select="TestCase">
+                    <xsl:call-template name="writeXUnitTestCase_Exec">
+                        <xsl:with-param name="id" select="@testId" />
+                        <xsl:with-param name="status" select="@status" />
+                        <xsl:with-param name="tcId" select="@id" />
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:call-template name="writeXUnitTestCase_Exec">
+                    <xsl:with-param name="id" select="@id" />
+                    <xsl:with-param name="status" select="@status" />
+                    <xsl:with-param name="tcId" select="'null'" />
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="writeXUnitTestCase_Exec">
+        <xsl:param name="id" />
+        <xsl:param name="status" />
+        <xsl:param name="tcId" select="'null'" />
+
+        <xsl:variable name="className">
+            <xsl:call-template name="getClassname" />
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$tcId='null'">
+
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViols">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id]" />
+                            <xsl:with-param name="unitViols" select="/ResultsSession/Exec/ExecViols/UnitViol[@testId=$id]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:when>
+            <xsl:otherwise>
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViols">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id and @tcId=$tcId]" />
+                            <xsl:with-param name="unitViols" select="/ResultsSession/Exec/ExecViols/UnitViol[@testId=$id and @tcId=$tcId]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processExecViols">
+        <xsl:param name="execViols" />
+        <xsl:param name="unitViols" />
+        <xsl:param name="status" />
+
+        <xsl:choose>
+            <xsl:when test="$status='err'">
+                <error type="Error">
+                    <xsl:call-template name="printUnitViols">
+                        <xsl:with-param name="unitViols" select="$unitViols" />
+                    </xsl:call-template>
+                    <xsl:call-template name="printExecViols">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </error>
+            </xsl:when>
+            <xsl:when test="$status='fail'">
+                <failure type="Failure">
+                    <xsl:call-template name="printUnitViols">
+                        <xsl:with-param name="unitViols" select="$unitViols" />
+                    </xsl:call-template>
+                    <xsl:call-template name="printExecViols">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </failure>
+            </xsl:when>
+        </xsl:choose>
+
+    </xsl:template>
+
+    <xsl:template name="printUnitViols">
+        <xsl:param name="unitViols" />
+        <xsl:if test="count($unitViols) > 0">
+            <xsl:call-template name="processStackTrace">
+                <xsl:with-param name="unitViols" select="$unitViols" />
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="processStackTrace">
+        <xsl:param name="unitViols"/>
+        <xsl:for-each select="$unitViols/Thr/ThrPart">
+            <xsl:sort select="position()" data-type="number" order="descending" />
+            <xsl:if test="position() != '1'">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>Caused by: </xsl:text>
+            </xsl:if>
+            <xsl:value-of select="concat(@type,': ',@msg)" />
+
+            <xsl:for-each select="PathElem">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>at </xsl:text>
+                <xsl:value-of select="@desc" />
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <xsl:template name="printExecViols">
+        <xsl:param name="execViols" />
+
+        <xsl:if test="count($execViols) > 0">
+            <xsl:choose>
+                <xsl:when test="count($execViols) > 1">
+                    <xsl:variable name="combinedFailures">
+                        <xsl:for-each select="$execViols">
+                            <xsl:if test="position() > 1 and string-length(@msg) > 0">
+                                <xsl:text>&#xa;&#x9;</xsl:text>
+                                <xsl:text>&#xa;&#x9;</xsl:text>
+                            </xsl:if>
+                            <xsl:value-of select="@msg" />
+                        </xsl:for-each>
+                    </xsl:variable>
+                    <xsl:attribute name="message">Multiple errors reported</xsl:attribute>
+                    <xsl:value-of select="$combinedFailures" />
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:attribute name="message"><xsl:value-of select="$execViols/@msg" /></xsl:attribute>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- =================  Execution results 9.x ================== -->
+
+    <xsl:template name="processLegacyExecutionResults">
+        <xsl:apply-templates select="/ResultsSession/ExecutedTestsDetails/Total" mode="execLegacy" />
+    </xsl:template>
+
+    <xsl:template match="Total" mode="execLegacy">
+        <testsuites>
+            <xsl:apply-templates select="Project/TestSuite | TestSuite" mode="execLegacy" />
+        </testsuites>
+    </xsl:template>
+
+    <xsl:template match="TestSuite" mode="execLegacy">
+        <xsl:choose>
+            <xsl:when test="parent::TestSuite">
+                <xsl:apply-templates select="Test" mode="execLegacy" />
+                <xsl:apply-templates select="TestSuite" mode="execLegacy"/>
+            </xsl:when>
+            <xsl:otherwise>
+
+                <testsuite name="{@name}" tests="{count(.//Test[not(TestCase)] | .//Test/TestCase)}"
+                           id="{position()}" package="">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addHostnameAttr"/>
+                    <xsl:call-template name="addTimestampAttr"/>
+                    <xsl:call-template name="addFailuresAttr"/>
+                    <xsl:call-template name="addErrorsAttr"/>
+                    <properties/>
+                    <xsl:apply-templates select="Test" mode="execLegacy" />
+                    <xsl:apply-templates select="TestSuite" mode="execLegacy" />
+                    <system-out/>
+                    <system-err/>
+                </testsuite>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getStatus">
+        <xsl:param name="testNode"/>
+
+        <xsl:if test="($testNode/@err) > 0">err</xsl:if>
+        <xsl:if test="not(($testNode/@err) > 0) and ($testNode/@fail) > 0">fail</xsl:if>
+        <xsl:if test="not(($testNode/@err) > 0) and not(($testNode/@fail) > 0) and ($testNode/@pass) > 0">pass</xsl:if>
+    </xsl:template>
+
+    <xsl:template match="Test" mode="execLegacy">
+        <xsl:choose>
+            <xsl:when test="TestCase">
+                <xsl:for-each select="TestCase">
+                    <xsl:variable name="status">
+                        <xsl:call-template name="getStatus">
+                            <xsl:with-param name="testNode" select="." />
+                        </xsl:call-template>
+                    </xsl:variable>
+                    <xsl:call-template name="writeXUnitTestCase_ExecLegacy">
+                        <xsl:with-param name="id" select="@testId" />
+                        <xsl:with-param name="status" select="$status" />
+                        <xsl:with-param name="tcId" select="@id" />
+                    </xsl:call-template>
+                </xsl:for-each>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="status">
+                    <xsl:call-template name="getStatus">
+                        <xsl:with-param name="testNode" select="." />
+                    </xsl:call-template>
+                </xsl:variable>
+                <xsl:call-template name="writeXUnitTestCase_ExecLegacy">
+                    <xsl:with-param name="id" select="@id" />
+                    <xsl:with-param name="status" select="$status" />
+                    <xsl:with-param name="tcId" select="'null'" />
+                </xsl:call-template>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="writeXUnitTestCase_ExecLegacy">
+        <xsl:param name="id" />
+        <xsl:param name="status" />
+        <xsl:param name="tcId" select="'null'" />
+
+        <xsl:variable name="className">
+            <xsl:call-template name="getClassname" />
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$tcId='null'">
+                <testcase name="{@name}" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViol_Legacy">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:variable name="testName" select="ancestor::Test[position()=1]/@name" />
+                <testcase name="{$testName}[{@params}]" classname="{$className}">
+                    <xsl:call-template name="addTimeAttr" />
+                    <xsl:call-template name="addFileAttr">
+                        <xsl:with-param name="tcId" select="$tcId" />
+                    </xsl:call-template>
+                    <xsl:if test="$status!='pass'">
+                        <xsl:call-template name="processExecViol_Legacy">
+                            <xsl:with-param name="execViols" select="/ResultsSession/Exec/ExecViols/ExecViol[@testId=$id and @testCaseId=$tcId]" />
+                            <xsl:with-param name="status" select="$status" />
+                        </xsl:call-template>
+                    </xsl:if>
+                </testcase>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processExecViol_Legacy">
+        <xsl:param name="execViols" />
+        <xsl:param name="status" />
+        <xsl:choose>
+            <xsl:when test="$status='err'">
+                <error type="Error">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:call-template name="processStackTrace_Legacy">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </error>
+            </xsl:when>
+            <xsl:when test="$status='fail'">
+                <failure type="Failure">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:call-template name="processStackTrace_Legacy">
+                        <xsl:with-param name="execViols" select="$execViols" />
+                    </xsl:call-template>
+                </failure>
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="processStackTrace_Legacy">
+        <xsl:param name="execViols"/>
+        <xsl:for-each select="$execViols">
+            <xsl:sort select="@ln" />
+            <xsl:if test="position() > 1">
+                <xsl:text>&#xa;&#x9;</xsl:text>
+                <xsl:text>&#xa;&#x9;</xsl:text>
+            </xsl:if>
+            <xsl:for-each select="./Thr/ThrPart">
+                <xsl:sort select="position()" data-type="number" order="descending" />
+                <xsl:if test="position() != '1'">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:text>Caused by: </xsl:text>
+                </xsl:if>
+                <xsl:value-of select="(@prnMsg)" />
+
+                <xsl:for-each select="Trace">
+                    <xsl:text>&#xa;&#x9;</xsl:text>
+                    <xsl:text>at </xsl:text>
+                    <xsl:if test="string-length(@ln) > 0">
+                        <xsl:value-of select="concat(@fileName,':',@ln)" />
+                    </xsl:if>
+                    <xsl:if test="not(string-length(@ln) > 0)">
+                        <xsl:value-of select="(@fileName)" />
+                    </xsl:if>
+                </xsl:for-each>
+            </xsl:for-each>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- =================  Utilities ================== -->
+
+    <xsl:template name="addTimeAttr">
+        <xsl:choose>
+            <xsl:when test="string-length(@time) > 0">
+                <xsl:attribute name="time">
+                    <xsl:call-template name="timeFormat">
+                        <xsl:with-param name="initTime" select="@time" />
+                    </xsl:call-template>
+                </xsl:attribute>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:attribute name="time">
+                    <xsl:value-of select="0"/>
+                </xsl:attribute>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="timeFormat">
+        <xsl:param name="initTime" />
+
+        <xsl:variable name="millis">
+            <xsl:value-of select="substring($initTime,9,3)" />
+        </xsl:variable>
+
+        <xsl:variable name="sec">
+            <xsl:value-of select="substring($initTime,6,2)" />
+        </xsl:variable>
+
+        <xsl:variable name="min">
+            <xsl:value-of select="substring($initTime,3,2)" />
+        </xsl:variable>
+
+        <xsl:variable name="hour">
+            <xsl:value-of select="substring($initTime,1,1)" />
+        </xsl:variable>
+
+        <xsl:variable name="allSec">
+            <xsl:value-of select="$sec + (60 * $min) + (3600 * $hour)" />
+        </xsl:variable>
+
+        <xsl:value-of select="concat($allSec,'.',$millis)" />
+    </xsl:template>
+
+    <xsl:template name="addFileAttr">
+        <xsl:param name="tcId" select="'null'" />
+        <xsl:attribute name="file">
+            <!-- The structure "/ResultsSession/Scope/Locations/Loc" is available in the reports of JTest, DOTTest, SOATest, C++ Standard,
+                 then also in C++Test Professional reports starting from 2024.1 when using -property report.additional.report.dir=<additional_report_dir>.
+                 The value of the file attribute can only be found with this situation. -->
+            <xsl:if test="/ResultsSession/Scope/Locations/Loc">
+                <xsl:choose>
+                    <!-- When "TestCase" node does not exist, use "locRef" of the current "Test" node for the test. -->
+                    <xsl:when test="$tcId = 'null'">
+                        <xsl:apply-templates select="/ResultsSession/Scope/Locations/Loc">
+                            <xsl:with-param name="testLocRef" select="@locRef"/>
+                        </xsl:apply-templates>
+                    </xsl:when>
+                    <!-- When "TestCase" node exists, use "locRef" of the nearest "Test" ancestor of the current node for the test. -->
+                    <xsl:otherwise>
+                        <xsl:apply-templates select="/ResultsSession/Scope/Locations/Loc">
+                            <xsl:with-param name="testLocRef" select="ancestor::Test[position()=1]/@locRef"/>
+                        </xsl:apply-templates>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:if>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template match="Loc">
+        <xsl:param name="testLocRef"/>
+        <xsl:if test="$testLocRef = @locRef">
+            <xsl:variable name="uncodedPipelineBuildWorkingDirectory">
+                <xsl:if test="string($pipelineBuildWorkingDirectory) != ''">
+                    <xsl:value-of select="concat(translate($pipelineBuildWorkingDirectory, '\', '/'), '/')"/>
+                </xsl:if>
+            </xsl:variable>
+            <xsl:variable name="encodedPipelineBuildWorkingDirectory">
+                <xsl:if test="string($uncodedPipelineBuildWorkingDirectory) != ''">
+                    <!-- Replace % with %25 and space with %20 to get an encoded path-->
+                    <xsl:value-of select="replace(replace($uncodedPipelineBuildWorkingDirectory, '%', '%25'), ' ', '%20')"/>
+                </xsl:if>
+            </xsl:variable>
+            <xsl:variable name="processedPipelineBuildWorkingDirectory">
+                <xsl:choose>
+                    <xsl:when test="string($uncodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $uncodedPipelineBuildWorkingDirectory)">
+                        <xsl:value-of select="$uncodedPipelineBuildWorkingDirectory"/>
+                    </xsl:when>
+                    <!-- Using encoded pipeline build working directory when the uri attribute of <Loc> tag in Parasoft tool report(e.g. jtest report) is encoded -->
+                    <xsl:when test="string($encodedPipelineBuildWorkingDirectory) != '' and contains(@uri, $encodedPipelineBuildWorkingDirectory)">
+                        <xsl:value-of select="$encodedPipelineBuildWorkingDirectory"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:value-of select="''"/>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:variable>
+            <xsl:variable name="isExternalReport" select="$processedPipelineBuildWorkingDirectory = ''"/>
+            <xsl:choose>
+                <xsl:when test="$isExternalReport">
+                    <xsl:value-of select="@uri"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <!-- Get relative source file path -->
+                    <xsl:value-of select="concat('./', substring-after(@uri, $processedPipelineBuildWorkingDirectory))"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="getClassname">
+        <xsl:choose>
+            <xsl:when test="$useFullClassName">
+                <xsl:call-template name="getFullClassName">
+                    <xsl:with-param name="currentNode"
+                                    select="ancestor::TestSuite[position()=1]" />
+                    <xsl:with-param name="depth">0</xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="ancestor::TestSuite[position()=1]/@name" />
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template name="getFullClassName">
+        <xsl:param name="currentNode" />
+        <xsl:param name="depth" />
+
+        <xsl:if
+                test="(name($currentNode) = 'TestSuite' or name($currentNode) = 'Project')">
+            <xsl:call-template name="getFullClassName">
+                <xsl:with-param name="currentNode"
+                                select="$currentNode/.." />
+                <xsl:with-param name="depth" select="($depth) + 1" />
+            </xsl:call-template>
+
+            <xsl:value-of select="$currentNode/@name" />
+
+            <xsl:if test="$depth = 1">
+                <xsl:text>.</xsl:text>
+            </xsl:if>
+            <xsl:if test="$depth > 1">
+                <xsl:text>/</xsl:text>
+            </xsl:if>
+        </xsl:if>
+
+    </xsl:template>
+
+    <xsl:template name="addHostnameAttr">
+        <xsl:attribute name="hostname">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="/ResultsSession/@machine"/>
+                <xsl:with-param name="defaultValue">-</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addTimestampAttr">
+        <xsl:attribute name="timestamp">
+            <xsl:variable name="dateAntJunitFormat" select="substring(/ResultsSession/@time, 1, 19)"/>
+            <xsl:choose>
+                <xsl:when test="string-length($dateAntJunitFormat) = 19">
+                    <xsl:value-of select="$dateAntJunitFormat"/>
+                </xsl:when>
+                <xsl:otherwise>
+                    <xsl:value-of select="'1111-11-11T00:00:00'"/>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addFailuresAttr">
+        <xsl:attribute name="failures">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="@fail"/>
+                <xsl:with-param name="defaultValue">0</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="addErrorsAttr">
+        <xsl:attribute name="errors">
+            <xsl:call-template name="getAttrValueOrDefault">
+                <xsl:with-param name="attr" select="@err"/>
+                <xsl:with-param name="defaultValue">0</xsl:with-param>
+            </xsl:call-template>
+        </xsl:attribute>
+    </xsl:template>
+
+    <xsl:template name="getAttrValueOrDefault">
+        <xsl:param name="attr" />
+        <xsl:param name="defaultValue" />
+
+        <xsl:choose>
+            <xsl:when test="$attr != ''">
+                <xsl:value-of select="$attr"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="$defaultValue"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file