tools: plugin: ov_noise_suppression: add regression test for adversarial model shapes

Add a regression test that exercises the input-shape guard introduced
in "tools: plugin: ov_noise_suppression: validate model input shape
dimensions". The test is a small C++ executable living next to the
module sources at
tools/plugin/modules/ov_noise_suppression/test_ns_shape_validation.cpp
and wired into the module's CMakeLists.txt inside the existing
if(OpenVINO_FOUND) block, so when OpenVINO is not installed the test
is skipped along with the module itself.

The test drives the public C API of the module
(ov_ns_init / ov_ns_free / NOISE_SUPPRESSION_MODEL_NAME) rather than
reaching into private structs, and is configurable from the command
line:

  --model PATH          use a caller-supplied OpenVINO model XML file.
  --dim N [--dim N ...] synthesize a minimal model XML with the given
                        input-port dimensions, write it to a temporary
                        file (mkstemps), and use that.
  --expect ok|reject    expected outcome; default "reject".
  -h, --help            print usage describing what the test does and
                        how to run it.

The mock-model writer emits the smallest XML that ov::Core::read_model()
will accept for a Parameter input with the configured shape, so
ov_ns_init() reaches the dimension-validation loop the previous commit
added. The test then asserts that ov_ns_init() returned 0 for
--expect ok and non-zero for --expect reject, and exits 0 (PASS) or 1
(FAIL) accordingly.

Two ctest cases are registered at CMake time covering the two
adversarial shapes that motivated the fix:

  ns_shape_zero      --dim 0 --dim 480                  # zero dim
  ns_shape_overflow  --dim 9223372036854775807 --dim 1024  # overflow

Real models can be exercised by invoking the executable directly with
--model PATH --expect ok.

Addresses review comments on PR #10886:

  r3403937663 - move test next to the module, build via the module's
                CMakeLists so OpenVINO/dep checks are reused.
  r3403939540 - take the model file / shape parameters on the command
                line instead of hard-coding /tmp/test_model_<pid>.xml.
  r3403944866 - add a -h help option describing the test and its usage.
  r3403950342 - add the missing SPDX-License-Identifier and copyright
                header; let CMake gate the build on OpenVINO presence.

Signed-off-by: OrbisAI Security <mediratta01.pally@gmail.com>

Author: orbisai0security

tools/plugin/modules/ov_noise_suppression/CMakeLists.txt

@@ -39,4 +39,22 @@ set_target_properties(sof_ns
 	INSTALL_RPATH "${sof_install_directory}/alsa-lib"
 	INSTALL_RPATH_USE_LINK_PATH TRUE
 )
+
+# Regression test for the input-shape validation guard. Gated on
+# OpenVINO_FOUND alongside the module itself, so a host without
+# OpenVINO simply skips it.
+add_executable(test_ns_shape_validation test_ns_shape_validation.cpp)
+target_link_libraries(test_ns_shape_validation PRIVATE sof_ns_interface)
+target_include_directories(test_ns_shape_validation PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${sof_source_directory}/src/include
+	${sof_source_directory}/posix/include
+	${sof_source_directory}/src/arch/host/include
+	${sof_source_directory}/src/platform/posix/include)
+set_target_properties(test_ns_shape_validation PROPERTIES LINKER_LANGUAGE CXX)
+
+add_test(NAME ns_shape_zero
+	COMMAND test_ns_shape_validation --dim 0 --dim 480)
+add_test(NAME ns_shape_overflow
+	COMMAND test_ns_shape_validation --dim 9223372036854775807 --dim 1024)
 endif()

tools/plugin/modules/ov_noise_suppression/test_ns_shape_validation.cpp

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 OrbisAI Security. All rights reserved.
+//
+// Author: OrbisAI Security <mediratta01.pally@gmail.com>
+
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <unistd.h>
+
+#include "noise_suppression_interface.h"
+
+static void usage(const char *prog)
+{
+	std::printf(
+"Usage: %s [--model PATH | --dim N [--dim N ...]] [--expect ok|reject]\n"
+"\n"
+"Regression test for the OpenVINO noise-suppression plugin's input-shape\n"
+"validation (commit \"tools: plugin: ov_noise_suppression: validate model\n"
+"input shape dimensions\"). Invokes ov_ns_init() against either:\n"
+"\n"
+"  --model PATH          a caller-supplied OpenVINO model XML file, or\n"
+"  --dim N [--dim N ...] a minimal synthesized model XML built from the\n"
+"                        given input port dimensions and written to a\n"
+"                        temporary file.\n"
+"\n"
+"  --expect ok|reject    expected outcome (default: reject).\n"
+"                        \"ok\":     ov_ns_init() must return 0.\n"
+"                        \"reject\": ov_ns_init() must return non-zero.\n"
+"\n"
+"Returns 0 on PASS, 1 on FAIL, 2 on usage error.\n"
+"\n"
+"Examples:\n"
+"  %s --dim 0 --dim 480                          # zero dim,  expect reject\n"
+"  %s --dim 9223372036854775807 --dim 1024       # overflow,  expect reject\n"
+"  %s --model real_model.xml --expect ok         # real model, expect accept\n",
+		prog, prog, prog, prog);
+}
+
+static int write_mock_model(const std::string &path,
+			    const std::vector<long long> &dims)
+{
+	std::ofstream f(path);
+	if (!f)
+		return -1;
+
+	f << "<?xml version=\"1.0\"?><net><layers>"
+	     "<layer id=\"0\" name=\"input\" type=\"Parameter\">"
+	     "<output><port id=\"0\" precision=\"FP32\">";
+	for (auto d : dims)
+		f << "<dim>" << d << "</dim>";
+	f << "</port></output></layer></layers></net>";
+	return f ? 0 : -1;
+}
+
+int main(int argc, char **argv)
+{
+	std::string model_path;
+	std::vector<long long> dims;
+	bool expect_reject = true;
+
+	for (int i = 1; i < argc; i++) {
+		std::string a = argv[i];
+		if (a == "-h" || a == "--help") {
+			usage(argv[0]);
+			return 0;
+		}
+		if (a == "--model" && i + 1 < argc) {
+			model_path = argv[++i];
+		} else if (a == "--dim" && i + 1 < argc) {
+			dims.push_back(std::strtoll(argv[++i], nullptr, 0));
+		} else if (a == "--expect" && i + 1 < argc) {
+			std::string v = argv[++i];
+			if (v == "ok") {
+				expect_reject = false;
+			} else if (v == "reject") {
+				expect_reject = true;
+			} else {
+				std::fprintf(stderr,
+					     "unknown --expect value: %s\n",
+					     v.c_str());
+				usage(argv[0]);
+				return 2;
+			}
+		} else {
+			std::fprintf(stderr, "unknown or incomplete arg: %s\n",
+				     a.c_str());
+			usage(argv[0]);
+			return 2;
+		}
+	}
+
+	std::string scratch;
+	if (model_path.empty()) {
+		if (dims.empty()) {
+			std::fprintf(stderr,
+				     "must supply --model PATH or one or more --dim N\n");
+			usage(argv[0]);
+			return 2;
+		}
+
+		char tmpl[] = "/tmp/ns_shape_test_XXXXXX.xml";
+		int fd = mkstemps(tmpl, 4);
+		if (fd < 0) {
+			std::perror("mkstemps");
+			return 2;
+		}
+		close(fd);
+		scratch = tmpl;
+		if (write_mock_model(scratch, dims) != 0) {
+			std::fprintf(stderr, "failed to write mock model %s\n",
+				     scratch.c_str());
+			std::remove(scratch.c_str());
+			return 2;
+		}
+		model_path = scratch;
+	}
+
+	setenv("NOISE_SUPPRESSION_MODEL_NAME", model_path.c_str(), 1);
+
+	ns_handle h = nullptr;
+	int rc = ov_ns_init(&h);
+	if (h)
+		ov_ns_free(h);
+
+	if (!scratch.empty())
+		std::remove(scratch.c_str());
+
+	bool rejected = (rc != 0);
+	bool pass = (rejected == expect_reject);
+
+	std::printf("model=%s rc=%d expect=%s -> %s\n", model_path.c_str(), rc,
+		    expect_reject ? "reject" : "ok",
+		    pass ? "PASS" : "FAIL");
+	return pass ? 0 : 1;
+}