end point adjsutments

tests/RenderCadenceCompositorRuntimeStateJsonTests.cpp

@@ -0,0 +1,89 @@
+#include "RuntimeStateJson.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace
+{
+int gFailures = 0;
+
+void ExpectContains(const std::string& text, const std::string& fragment, const std::string& message)
+{
+	if (text.find(fragment) != std::string::npos)
+		return;
+
+	++gFailures;
+	std::cerr << "FAIL: " << message << "\n";
+}
+
+ShaderPackage MakePackage()
+{
+	ShaderPackage package;
+	package.id = "solid-color";
+	package.displayName = "Solid Color";
+	package.description = "A single color shader.";
+	package.category = "Generator";
+
+	ShaderPassDefinition pass;
+	pass.id = "main";
+	package.passes.push_back(pass);
+
+	ShaderParameterDefinition color;
+	color.id = "color";
+	color.label = "Color";
+	color.description = "Output color.";
+	color.type = ShaderParameterType::Color;
+	color.defaultNumbers = { 1.0, 0.25, 0.5, 1.0 };
+	color.minNumbers = { 0.0, 0.0, 0.0, 0.0 };
+	color.maxNumbers = { 1.0, 1.0, 1.0, 1.0 };
+	color.stepNumbers = { 0.01, 0.01, 0.01, 0.01 };
+	package.parameters.push_back(color);
+	return package;
+}
+}
+
+int main()
+{
+	RenderCadenceCompositor::AppConfig config = RenderCadenceCompositor::DefaultAppConfig();
+	config.outputVideoFormat = "1080p";
+	config.outputFrameRate = "59.94";
+
+	RenderCadenceCompositor::CadenceTelemetrySnapshot telemetry;
+	telemetry.renderFps = 59.94;
+	telemetry.shaderBuildsCommitted = 1;
+
+	std::vector<RenderCadenceCompositor::SupportedShaderSummary> shaders = {
+		{ "solid-color", "Solid Color", "A single color shader.", "Generator" }
+	};
+	const ShaderPackage package = MakePackage();
+
+	const std::string json = RenderCadenceCompositor::RuntimeStateToJson(RenderCadenceCompositor::RuntimeStateJsonInput{
+		config,
+		telemetry,
+		8080,
+		true,
+		"DeckLink scheduled output running.",
+		shaders,
+		true,
+		"Runtime shader committed.",
+		&package
+	});
+
+	ExpectContains(json, "\"shaders\":[{\"id\":\"solid-color\"", "state JSON should include supported shaders");
+	ExpectContains(json, "\"layerCount\":1", "state JSON should expose the display layer count");
+	ExpectContains(json, "\"layers\":[{\"id\":\"runtime-layer-1\"", "state JSON should expose the active display layer");
+	ExpectContains(json, "\"parameters\":[{\"id\":\"color\"", "state JSON should expose active shader parameters");
+	ExpectContains(json, "\"type\":\"color\"", "state JSON should serialize parameter types for the UI");
+	ExpectContains(json, "\"width\":1920", "state JSON should expose output width");
+	ExpectContains(json, "\"height\":1080", "state JSON should expose output height");
+
+	if (gFailures != 0)
+	{
+		std::cerr << gFailures << " RenderCadenceCompositorRuntimeStateJson test failure(s).\n";
+		return 1;
+	}
+
+	std::cout << "RenderCadenceCompositorRuntimeStateJson tests passed.\n";
+	return 0;
+}

tests/RenderCadenceCompositorSupportedShaderCatalogTests.cpp

@@ -0,0 +1,113 @@
+#include "SupportedShaderCatalog.h"
+
+#include <iostream>
+#include <string>
+
+namespace
+{
+int gFailures = 0;
+
+void Expect(bool condition, const std::string& message)
+{
+	if (condition)
+		return;
+
+	++gFailures;
+	std::cerr << "FAIL: " << message << "\n";
+}
+
+ShaderPackage MakeSinglePassPackage()
+{
+	ShaderPackage shaderPackage;
+	shaderPackage.id = "supported";
+	ShaderPassDefinition pass;
+	pass.id = "main";
+	pass.entryPoint = "mainImage";
+	shaderPackage.passes.push_back(pass);
+	return shaderPackage;
+}
+
+void SupportsSinglePassStatelessPackage()
+{
+	const ShaderPackage shaderPackage = MakeSinglePassPackage();
+	const RenderCadenceCompositor::ShaderSupportResult result =
+		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+
+	Expect(result.supported, "single-pass stateless packages should be supported");
+	Expect(result.reason.empty(), "supported packages should not report a rejection reason");
+}
+
+void RejectsMultipassPackage()
+{
+	ShaderPackage shaderPackage = MakeSinglePassPackage();
+	ShaderPassDefinition secondPass;
+	secondPass.id = "second";
+	secondPass.entryPoint = "mainImage";
+	shaderPackage.passes.push_back(secondPass);
+
+	const RenderCadenceCompositor::ShaderSupportResult result =
+		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+
+	Expect(!result.supported, "multipass packages should be rejected");
+	Expect(result.reason.find("single-pass") != std::string::npos, "multipass rejection should explain the single-pass limit");
+}
+
+void RejectsTemporalPackage()
+{
+	ShaderPackage shaderPackage = MakeSinglePassPackage();
+	shaderPackage.temporal.enabled = true;
+
+	const RenderCadenceCompositor::ShaderSupportResult result =
+		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+
+	Expect(!result.supported, "temporal packages should be rejected");
+	Expect(result.reason.find("temporal") != std::string::npos, "temporal rejection should mention temporal storage");
+}
+
+void RejectsTextureAssets()
+{
+	ShaderPackage shaderPackage = MakeSinglePassPackage();
+	ShaderTextureAsset asset;
+	asset.id = "lut";
+	shaderPackage.textureAssets.push_back(asset);
+
+	const RenderCadenceCompositor::ShaderSupportResult result =
+		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+
+	Expect(!result.supported, "texture-backed packages should be rejected for now");
+	Expect(result.reason.find("texture") != std::string::npos, "texture rejection should mention texture assets");
+}
+
+void RejectsTextParameters()
+{
+	ShaderPackage shaderPackage = MakeSinglePassPackage();
+	ShaderParameterDefinition parameter;
+	parameter.id = "caption";
+	parameter.type = ShaderParameterType::Text;
+	shaderPackage.parameters.push_back(parameter);
+
+	const RenderCadenceCompositor::ShaderSupportResult result =
+		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+
+	Expect(!result.supported, "text-parameter packages should be rejected for now");
+	Expect(result.reason.find("text") != std::string::npos, "text rejection should mention text parameters");
+}
+}
+
+int main()
+{
+	SupportsSinglePassStatelessPackage();
+	RejectsMultipassPackage();
+	RejectsTemporalPackage();
+	RejectsTextureAssets();
+	RejectsTextParameters();
+
+	if (gFailures != 0)
+	{
+		std::cerr << gFailures << " RenderCadenceCompositorSupportedShaderCatalog test failure(s).\n";
+		return 1;
+	}
+
+	std::cout << "RenderCadenceCompositorSupportedShaderCatalog tests passed.\n";
+	return 0;
+}