wip

Author: sonalideshpandemsft

packages/dds/matrix/src/test/fuzz.ts

@@ -19,6 +19,8 @@ import { isFluidHandle, toFluidHandleInternal } from "@fluidframework/runtime-ut
 import type { MatrixItem } from "../ops.js";
 import { SharedMatrix, type SharedMatrixFactory } from "../runtime.js";
 
+import { hasSharedMatrixOracle } from "./matrixOracle.js";
+
 /**
  * Supported cell values used within the fuzz model.
  */
@@ -225,7 +227,17 @@ export const baseSharedMatrixModel: Omit<
 	factory: SharedMatrix.getFactory(),
 	generatorFactory: () => takeAsync(50, makeGenerator()),
 	reducer: (state, operation) => reducer(state, operation),
-	validateConsistency: async (a, b) => assertMatricesAreEquivalent(a.channel, b.channel),
+	validateConsistency: async (a, b) => {
+		if (hasSharedMatrixOracle(a.channel)) {
+			a.channel.matrixOracle.validate();
+		}
+
+		if (hasSharedMatrixOracle(b.channel)) {
+			b.channel.matrixOracle.validate();
+		}
+
+		return assertMatricesAreEquivalent(a.channel, b.channel);
+	},
 	minimizationTransforms: ["count", "start", "row", "col"].map((p) => (op) => {
 		if (p in op && typeof op[p] === "number" && op[p] > 0) {
 			op[p]--;

packages/dds/matrix/src/test/matrix.fuzz.spec.ts

@@ -63,7 +63,7 @@ describe("Matrix fuzz tests", function () {
 		...baseOptions,
 		reconnectProbability: 0,
 		// Uncomment to replay a particular seed.
-		// replay: 0,
+		// only: 97,
 		skip: [4, 54, 73, 97],
 		saveFailures: { directory: path.join(_dirname, "../../../src/test/mocha/results/1") },
 	});

packages/dds/matrix/src/test/matrixOracle.ts

@@ -7,31 +7,78 @@ import { strict as assert } from "node:assert";
 
 import type { ISharedMatrix, SharedMatrix } from "../matrix.js";
 
-/**
- * @internal
- */
+import { TestConsumer } from "./testconsumer.js";
+
 export class SharedMatrixOracle {
-	constructor(private readonly shared: ISharedMatrix) {
-		this.shared.on("conflict", (row, col, currentValue, conflictingValue, target) => {
-			if (row < this.shared.rowCount && col < this.shared.colCount) {
-				assert(
-					this.shared.isSetCellConflictResolutionPolicyFWW(),
-					"Conflict should only fire in FWW mode",
-				);
+	private readonly testConsumer: TestConsumer;
+	private readonly conflictListener: (
+		row: number,
+		col: number,
+		currentValue: unknown,
+		conflictingValue: unknown,
+	) => void;
+
+	constructor(private readonly shared: SharedMatrix) {
+		this.testConsumer = new TestConsumer(shared);
+
+		this.conflictListener = (row, col, currentValue, conflictingValue) => {
+			this.onConflict(row, col, currentValue, conflictingValue);
+		};
+
+		this.shared.on("conflict", this.conflictListener);
+	}
+
+	private onConflict(
+		row: number,
+		col: number,
+		currentValue: unknown,
+		conflictingValue: unknown,
+	): void {
+		assert.ok(
+			this.shared.isSetCellConflictResolutionPolicyFWW(),
+			"Conflict should only fire in FWW mode",
+		);
+
+		if (row < this.shared.rowCount && col < this.shared.colCount) {
+			assert(
+				this.shared.isSetCellConflictResolutionPolicyFWW(),
+				"Conflict should only fire in FWW mode",
+			);
 
-				const actual = this.shared.getCell(row, col);
+			const actual = this.testConsumer.getCell(row, col);
 
-				// The loser must be different
-				assert.notDeepStrictEqual(currentValue, conflictingValue);
+			// The loser must be different
+			assert.notDeepStrictEqual(currentValue, conflictingValue);
 
-				// The cell contains the winner
-				assert.deepStrictEqual(
+			// The cell contains the winner
+			assert.deepStrictEqual(
+				actual,
+				currentValue,
+				`Conflict mismatch at [${row},${col}]: expected winner=${currentValue}, actual=${actual} with conflicting value=${conflictingValue}`,
+			);
+		}
+	}
+
+	public validate(): void {
+		const rows = this.shared.rowCount;
+		const cols = this.shared.colCount;
+
+		// Validate the entire matrix
+		for (let r = 0; r < rows; r++) {
+			for (let c = 0; c < cols; c++) {
+				const expected = this.testConsumer.getCell(r, c);
+				const actual = this.shared.getCell(r, c);
+				assert.strictEqual(
 					actual,
-					currentValue,
-					`Conflict mismatch at [${row},${col}]: expected winner=${currentValue}, actual=${actual} with conflicting value=${conflictingValue}`,
+					expected,
+					`Mismatch at [${r},${c}]: expected="${expected}", actual="${actual}"`,
 				);
 			}
-		});
+		}
+	}
+
+	public dispose(): void {
+		this.shared.off("conflict", this.conflictListener);
 	}
 }
 
@@ -41,3 +88,11 @@ export class SharedMatrixOracle {
 export interface IChannelWithOracles extends SharedMatrix {
 	matrixOracle: SharedMatrixOracle;
 }
+
+/**
+ * Type guard for SharedMatrix with an oracle
+ * @internal
+ */
+export function hasSharedMatrixOracle(s: ISharedMatrix): s is IChannelWithOracles {
+	return "matrixOracle" in s && s.matrixOracle instanceof SharedMatrixOracle;
+}