update as per review

mw-kapilg · mw-kapilg · commit 5e4da84753ec · 2026-07-28T01:52:43.000+05:30
diff --git a/action.yml b/action.yml
@@ -91,7 +91,7 @@ inputs:
     default: true
   code-coverage-metrics:
     description: >-
-      Level of coverage metrics to collect
+      Code coverage metrics to collect
     required: false
     default: auto
 runs:
diff --git a/plugins/+matlab/+unittest/+internal/+services/+plugins/CodeCoverageSummaryPluginService.m b/plugins/+matlab/+unittest/+internal/+services/+plugins/CodeCoverageSummaryPluginService.m
@@ -7,29 +7,48 @@
             hasCoverageCobertura = ~isempty(getenv('MW_INPUT_CODE_COVERAGE_COBERTURA'));
             hasCoverageRequest = hasCoverageHTML || hasCoverageCobertura;
 
-            if strcmpi(getenv("MW_INPUT_GENERATE_SUMMARY"), "true") && ~hasCoverageRequest
-                % Get metric level from environment variable
-                metricLevel = getenv('MW_INPUT_CODE_COVERAGE_METRICS');
+            metricsStr = strtrim(getenv('MW_INPUT_CODE_COVERAGE_METRICS'));
+            if strcmpi(getenv("MW_INPUT_GENERATE_SUMMARY"), "true") && ~hasCoverageRequest && ~isempty(metricsStr)
+                % Parse metrics from environment variable (space-separated)
+                metrics = strsplit(strtrim(metricsStr));
+
+                % Resolve 'auto' to appropriate metrics
+                if isscalar(metrics) && strcmpi(metrics{1}, 'auto')
+                    if any(strcmp({ver().Name}, 'MATLAB Test')) && license('test', 'MATLAB_Test')
+                        if ~isMATLABReleaseOlderThan("R2023a")
+                            metrics = {'mcdc'};
+                        else
+                            metrics = {'statement'};
+                        end
+                    else
+                        metrics = {'statement'};
+                    end
+                end
 
                 % Create a shared CoverageResult format object
                 format = matlab.unittest.plugins.codecoverage.CoverageResult;
-                
+
                 % Create an array to hold multiple plugins
                 plugins = matlab.unittest.plugins.TestRunnerPlugin.empty(0);
-                
+
                 % Get source folder from environment variable
                 sourceFolder = getenv('MW_INPUT_SOURCE_FOLDER');
                 if isempty(sourceFolder)
                     sourceFolder = pwd;
                 end
-                
-                coveragePlugin = matlab.unittest.plugins.CodeCoveragePlugin.forFolder(...
-                    sourceFolder, 'Producing', format, 'MetricLevel', metricLevel);
+
+                if isMATLABReleaseOlderThan("R2026b")
+                    coveragePlugin = matlab.unittest.plugins.CodeCoveragePlugin.forFolder(...
+                        sourceFolder, 'Producing', format, 'MetricLevel', metrics);
+                else
+                    coveragePlugin = matlab.unittest.plugins.CodeCoveragePlugin.forFolder(...
+                        sourceFolder, 'Producing', format, 'Metrics', metrics);
+                end
 
                 plugins(end+1) = coveragePlugin;
-                
+
                 % Add the summary plugin with the same format object
-                summaryPlugin = testframework.CodeCoverageSummaryPlugin(format, metricLevel);
+                summaryPlugin = testframework.CodeCoverageSummaryPlugin(format, metrics);
                 plugins(end+1) = summaryPlugin;
             else
                 plugins = matlab.unittest.plugins.TestRunnerPlugin.empty(1,0);
diff --git a/plugins/+testframework/CodeCoverageSummaryPlugin.m b/plugins/+testframework/CodeCoverageSummaryPlugin.m
@@ -3,13 +3,13 @@
     
     properties (Access=private)
         CoverageFormat
-        MetricLevel
+        Metrics
     end
     
     methods
-        function plugin = CodeCoverageSummaryPlugin(coverageFormat, metricLevel)
+        function plugin = CodeCoverageSummaryPlugin(coverageFormat, metrics)
             plugin.CoverageFormat = coverageFormat;
-            plugin.MetricLevel = metricLevel;
+            plugin.Metrics = metrics;
         end
     end
     
@@ -28,29 +28,28 @@ function runSession(plugin, pluginData)
             
             % Create coverage summary structure
             coverageDetails = struct();
-            coverageDetails.MetricLevel = plugin.MetricLevel;
-            
-            % Always get function and statement coverage (available for all levels)
+
+            % Always get function and statement coverage
             functionCoverage = coverageSummary(result, "function");
             statementCoverage = coverageSummary(result, "statement");
-            
+
             coverageDetails.FunctionCoverage = sumCoverage(functionCoverage);
             coverageDetails.StatementCoverage = sumCoverage(statementCoverage);
-            
-            % Get decision coverage if metric level is decision, condition, or mcdc
-            if ismember(plugin.MetricLevel, {'decision', 'condition', 'mcdc'})
+
+            % Get decision coverage if metrics contains decision, condition, or mcdc
+            if any(ismember({'decision', 'condition', 'mcdc'}, plugin.Metrics))
                 decisionCoverage = coverageSummary(result, "decision");
                 coverageDetails.DecisionCoverage = sumCoverage(decisionCoverage);
             end
-            
-            % Get condition coverage if metric level is condition or mcdc
-            if ismember(plugin.MetricLevel, {'condition', 'mcdc'})
+
+            % Get condition coverage if metrics contains condition or mcdc
+            if any(ismember({'condition', 'mcdc'}, plugin.Metrics))
                 conditionCoverage = coverageSummary(result, "condition");
                 coverageDetails.ConditionCoverage = sumCoverage(conditionCoverage);
             end
-            
-            % Get MC/DC coverage if metric level is mcdc
-            if strcmp(plugin.MetricLevel, 'mcdc')
+
+            % Get MC/DC coverage if metrics contains mcdc
+            if any(ismember({'mcdc'}, plugin.Metrics))
                 mcdcCoverage = coverageSummary(result, "mcdc");
                 coverageDetails.MCDCCoverage = sumCoverage(mcdcCoverage);
             end
diff --git a/src/index.ts b/src/index.ts
@@ -13,6 +13,8 @@ async function run() {
     const architecture = process.arch;
     const workspaceDir = process.cwd();
 
+    const codeCoverageMetrics = core.getInput("code-coverage-metrics").toLowerCase().trim();
+
     const options: scriptgen.RunTestsOptions = {
         JUnitTestResults: core.getInput("test-results-junit"),
         CoberturaCodeCoverage: core.getInput("code-coverage-cobertura"),
@@ -29,19 +31,10 @@ async function run() {
         UseParallel: core.getBooleanInput("use-parallel"),
         OutputDetail: core.getInput("output-detail"),
         LoggingLevel: core.getInput("logging-level"),
+        CodeCoverageMetrics: codeCoverageMetrics,
     };
 
     const generateSummary = core.getBooleanInput("generate-summary");
-    var codeCoverageMetrics = core.getInput("code-coverage-metrics").toLowerCase();
-
-    // Validate metric level
-    const validMetricLevels = ["auto", "statement", "decision", "condition", "mcdc"];
-    if (!validMetricLevels.includes(codeCoverageMetrics)) {
-        core.warning(
-            `Invalid metric level '${codeCoverageMetrics}'. Using the default value ('auto') instead.`,
-        );
-        codeCoverageMetrics = "auto";
-    }
 
     const command = scriptgen.generateCommand(options);
     const startupOptions = core.getInput("startup-options").split(" ");
@@ -51,7 +44,7 @@ async function run() {
         env: {
             ...process.env,
             MW_BATCH_LICENSING_ONLINE: "true", // Remove when online batch licensing is the default
-            MW_INPUT_CODE_COVERAGE_METRICS: codeCoverageMetrics,
+            MW_INPUT_CODE_COVERAGE_METRICS: options.CodeCoverageMetrics!,
             MW_INPUT_SOURCE_FOLDER: options.SourceFolder!, // Add source folder to environment
             MW_INPUT_CODE_COVERAGE_HTML: options.HTMLCodeCoverage!,
             MW_INPUT_CODE_COVERAGE_COBERTURA: options.CoberturaCodeCoverage!,
diff --git a/src/scriptgen.ts b/src/scriptgen.ts
@@ -1,4 +1,4 @@
-// Copyright 2020-2022 The MathWorks, Inc.
+// Copyright 2020-2026 The MathWorks, Inc.
 
 import * as path from "path";
 
@@ -22,6 +22,15 @@ export interface RunTestsOptions {
     UseParallel?: boolean;
     OutputDetail?: string;
     LoggingLevel?: string;
+    CodeCoverageMetrics?: string;
+}
+
+function formatMetricsCellArray(metrics: string | undefined): string {
+    if (!metrics || metrics.trim() === "") {
+        return "{}";
+    }
+    const items = metrics.trim().split(/\s+/).map(m => `'${m}'`).join(",");
+    return `{${items}}`;
 }
 
 /**
@@ -30,6 +39,7 @@ export interface RunTestsOptions {
  * @param options scriptgen options for running tests.
  */
 export function generateCommand(options: RunTestsOptions): string {
+    const metricsCellArray = formatMetricsCellArray(options.CodeCoverageMetrics);
     const command = `
         addpath('${path.join(import.meta.dirname, "scriptgen")}');
         testScript = genscript('Test',
@@ -47,7 +57,8 @@ export function generateCommand(options: RunTestsOptions): string {
             'Strict',${options.Strict || false},
             'UseParallel',${options.UseParallel || false},
             'OutputDetail','${options.OutputDetail || ""}',
-            'LoggingLevel','${options.LoggingLevel || ""}'
+            'LoggingLevel','${options.LoggingLevel || ""}',
+            'Metrics',${metricsCellArray}
             );
         disp('Running MATLAB script with contents:');
         disp(testScript.Contents);
diff --git a/src/scriptgen.unit.test.ts b/src/scriptgen.unit.test.ts
@@ -1,4 +1,4 @@
-// Copyright 2020-2022 The MathWorks, Inc.
+// Copyright 2020-2026 The MathWorks, Inc.
 
 import * as scriptgen from "./scriptgen.js";
 
@@ -20,6 +20,7 @@ describe("command generation", () => {
             UseParallel: false,
             OutputDetail: "",
             LoggingLevel: "",
+            CodeCoverageMetrics: "",
         };
 
         const actual = scriptgen.generateCommand(options);
@@ -40,18 +41,30 @@ describe("command generation", () => {
         expect(actual.includes("'UseParallel',false")).toBeTruthy();
         expect(actual.includes("'OutputDetail',''")).toBeTruthy();
         expect(actual.includes("'LoggingLevel',''")).toBeTruthy();
+        expect(actual.includes("'Metrics',{}")).toBeTruthy();
 
         const expected =
-            `genscript('Test', 'JUnitTestResults','', 'CoberturaCodeCoverage','', 'HTMLCodeCoverage','', 
-        'SourceFolder','', 'PDFTestReport','', 'HTMLTestReport','', 'SimulinkTestResults','', 
-        'CoberturaModelCoverage','', 'HTMLModelCoverage','', 'SelectByTag','', 'SelectByFolder','', 
-        'Strict',false, 'UseParallel',false, 'OutputDetail','', 'LoggingLevel','')`.replace(
+            `genscript('Test', 'JUnitTestResults','', 'CoberturaCodeCoverage','', 'HTMLCodeCoverage','',
+        'SourceFolder','', 'PDFTestReport','', 'HTMLTestReport','', 'SimulinkTestResults','',
+        'CoberturaModelCoverage','', 'HTMLModelCoverage','', 'SelectByTag','', 'SelectByFolder','',
+        'Strict',false, 'UseParallel',false, 'OutputDetail','', 'LoggingLevel','',
+        'Metrics',{})`.replace(
                 /\s+/g,
                 "",
             );
         expect(actual.replace(/\s+/g, "").includes(expected)).toBeTruthy();
     });
 
+    it("contains genscript invocation with single metrics value", () => {
+        const options: scriptgen.RunTestsOptions = {
+            CodeCoverageMetrics: "statement",
+        };
+
+        const actual = scriptgen.generateCommand(options);
+
+        expect(actual.includes("'Metrics',{'statement'}")).toBeTruthy();
+    });
+
     it("contains genscript invocation with all options specified", () => {
         const options: scriptgen.RunTestsOptions = {
             JUnitTestResults: "test-results/results.xml",
@@ -69,6 +82,7 @@ describe("command generation", () => {
             UseParallel: true,
             OutputDetail: "Detailed",
             LoggingLevel: "Detailed",
+            CodeCoverageMetrics: "mcdc type-size",
         };
 
         const actual = scriptgen.generateCommand(options);
@@ -97,23 +111,25 @@ describe("command generation", () => {
         expect(actual.includes("'UseParallel',true")).toBeTruthy();
         expect(actual.includes("'OutputDetail','Detailed'")).toBeTruthy();
         expect(actual.includes("'LoggingLevel','Detailed'")).toBeTruthy();
+        expect(actual.includes("'Metrics',{'mcdc','type-size'}")).toBeTruthy();
 
-        const expected = `genscript('Test', 
-        'JUnitTestResults','test-results/results.xml', 
+        const expected = `genscript('Test',
+        'JUnitTestResults','test-results/results.xml',
         'CoberturaCodeCoverage','code-coverage/coverage.xml',
-        'HTMLCodeCoverage','code-coverage/coverage.html', 
+        'HTMLCodeCoverage','code-coverage/coverage.html',
         'SourceFolder','source',
-        'PDFTestReport','test-results/pdf-results.pdf', 
-        'HTMLTestReport','test-results/html-results.html', 
+        'PDFTestReport','test-results/pdf-results.pdf',
+        'HTMLTestReport','test-results/html-results.html',
         'SimulinkTestResults','test-results/simulinkTest.mldatx',
-        'CoberturaModelCoverage','test-results/modelcoverage.xml', 
-        'HTMLModelCoverage','test-results/modelcoverage.html', 
-        'SelectByTag','FeatureA', 
-        'SelectByFolder','test/tools;test/toolbox', 
-        'Strict',true, 
-        'UseParallel',true, 
-        'OutputDetail','Detailed', 
-        'LoggingLevel','Detailed' )`.replace(/\s+/g, "");
+        'CoberturaModelCoverage','test-results/modelcoverage.xml',
+        'HTMLModelCoverage','test-results/modelcoverage.html',
+        'SelectByTag','FeatureA',
+        'SelectByFolder','test/tools;test/toolbox',
+        'Strict',true,
+        'UseParallel',true,
+        'OutputDetail','Detailed',
+        'LoggingLevel','Detailed',
+        'Metrics',{'mcdc','type-size'})`.replace(/\s+/g, "");
         expect(actual.replace(/\s+/g, "").includes(expected)).toBeTruthy();
     });
 });
