@wordpress/interactivity-router 2.25.0 → 2.26.1-next.719a03cbe.0

package/src/assets/test/scs.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Internal dependencies
+ */
+import { shortestCommonSupersequence } from '../scs';
+
+/**
+ * Checks if the passed array is a contained sequence of the given
+ * supersequence.
+ *
+ * @param arr      Array.
+ * @param superseq Supersequence.
+ * @param isEqual  Optional comparator.
+ * @return True if the passed array is contained. False otherwise.
+ */
+function isSubsequence(
+	arr: unknown[],
+	superseq: unknown[],
+	isEqual = ( a: unknown, b: unknown ): boolean => a === b
+) {
+	let i = 0;
+	let j = 0;
+	while ( i < arr.length && j < superseq.length ) {
+		if ( isEqual( arr[ i ], superseq[ j ] ) ) {
+			i++;
+		}
+		j++;
+	}
+	return i === arr.length;
+}
+
+describe( 'shortestCommonSupersequence', () => {
+	describe( 'Basic functionality', () => {
+		it( 'should handle empty arrays', () => {
+			// Both arrays empty.
+			expect( shortestCommonSupersequence( [], [] ) ).toEqual( [] );
+
+			// X empty, Y with values.
+			const Y = [ 1, 2, 3 ];
+			expect( shortestCommonSupersequence( [], Y ) ).toEqual( Y );
+
+			// Y empty, X with values.
+			const X = [ 1, 2, 3 ];
+			expect( shortestCommonSupersequence( X, [] ) ).toEqual( X );
+		} );
+
+		it( 'should handle identical arrays', () => {
+			// Same elements, same order.
+			const X = [ 1, 2, 3 ];
+			const Y = [ 1, 2, 3 ];
+			expect( shortestCommonSupersequence( X, Y ) ).toEqual( [
+				1, 2, 3,
+			] );
+		} );
+
+		it( 'should handle simple cases with partial overlap', () => {
+			// Overlap at the beginning.
+			const result1 = shortestCommonSupersequence(
+				[ 1, 2, 3 ],
+				[ 1, 2, 4 ]
+			);
+			// Verify it's a valid supersequence.
+			expect( isSubsequence( [ 1, 2, 3 ], result1 ) ).toBe( true );
+			expect( isSubsequence( [ 1, 2, 4 ], result1 ) ).toBe( true );
+			// Verify optimal length.
+			expect( result1.length ).toBe( 4 );
+
+			// Overlap at the end.
+			const result2 = shortestCommonSupersequence(
+				[ 1, 2, 3 ],
+				[ 0, 2, 3 ]
+			);
+			// Verify it's a valid supersequence.
+			expect( isSubsequence( [ 1, 2, 3 ], result2 ) ).toBe( true );
+			expect( isSubsequence( [ 0, 2, 3 ], result2 ) ).toBe( true );
+			// Verify optimal length.
+			expect( result2.length ).toBe( 4 );
+
+			// Middle overlap.
+			const result3 = shortestCommonSupersequence(
+				[ 1, 2, 3 ],
+				[ 0, 2, 4 ]
+			);
+			// Verify it's a valid supersequence.
+			expect( isSubsequence( [ 1, 2, 3 ], result3 ) ).toBe( true );
+			expect( isSubsequence( [ 0, 2, 4 ], result3 ) ).toBe( true );
+			// Verify optimal length.
+			expect( result3.length ).toBe( 5 );
+		} );
+
+		it( 'should handle arrays with no overlap', () => {
+			const X = [ 1, 2, 3 ];
+			const Y = [ 4, 5, 6 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Result length should be X.length + Y.length.
+			expect( result.length ).toBe( X.length + Y.length );
+		} );
+
+		it( 'should verify the supersequence length is optimal', () => {
+			// Example where the shortest supersequence is shorter than just concatenating.
+			const X = [ 1, 2, 3 ];
+			const Y = [ 2, 3, 4 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			expect( result.length ).toBe( 4 );
+			expect( result ).toEqual( [ 1, 2, 3, 4 ] );
+		} );
+	} );
+
+	describe( 'Edge cases', () => {
+		it( 'should handle subsequence cases', () => {
+			// X is a subsequence of Y.
+			const X1 = [ 1, 3 ];
+			const Y1 = [ 1, 2, 3, 4 ];
+			expect( shortestCommonSupersequence( X1, Y1 ) ).toEqual( Y1 );
+
+			// Y is a subsequence of X.
+			const X2 = [ 1, 2, 3, 4 ];
+			const Y2 = [ 1, 3 ];
+			expect( shortestCommonSupersequence( X2, Y2 ) ).toEqual( X2 );
+		} );
+
+		it( 'should handle arrays with duplicate elements', () => {
+			// Duplicates in X.
+			const resultX = shortestCommonSupersequence(
+				[ 1, 2, 2, 3 ],
+				[ 1, 3, 4 ]
+			);
+			expect( isSubsequence( [ 1, 2, 2, 3 ], resultX ) ).toBe( true );
+			expect( isSubsequence( [ 1, 3, 4 ], resultX ) ).toBe( true );
+			expect( resultX.length ).toBe( 5 );
+
+			// Duplicates in Y.
+			const resultY = shortestCommonSupersequence(
+				[ 1, 3, 4 ],
+				[ 1, 2, 2, 3 ]
+			);
+			expect( isSubsequence( [ 1, 3, 4 ], resultY ) ).toBe( true );
+			expect( isSubsequence( [ 1, 2, 2, 3 ], resultY ) ).toBe( true );
+			expect( resultY.length ).toBe( 5 );
+
+			// Duplicates in both X and Y.
+			const resultXY = shortestCommonSupersequence(
+				[ 1, 2, 2, 3 ],
+				[ 1, 2, 3, 3 ]
+			);
+			expect( isSubsequence( [ 1, 2, 2, 3 ], resultXY ) ).toBe( true );
+			expect( isSubsequence( [ 1, 2, 3, 3 ], resultXY ) ).toBe( true );
+			expect( resultXY.length ).toBe( 5 );
+
+			// Multiple duplicate occurrences.
+			const result = shortestCommonSupersequence(
+				[ 1, 2, 1, 2 ],
+				[ 2, 1, 2, 1 ]
+			);
+
+			expect( isSubsequence( [ 1, 2, 1, 2 ], result ) ).toBe( true );
+			expect( isSubsequence( [ 2, 1, 2, 1 ], result ) ).toBe( true );
+			expect( result.length ).toBe( 5 );
+		} );
+
+		it( 'should handle completely duplicate array', () => {
+			expect(
+				shortestCommonSupersequence( [ 1, 1, 1 ], [ 1, 1 ] )
+			).toEqual( [ 1, 1, 1 ] );
+		} );
+
+		it( 'should handle asymmetric cases with different array lengths', () => {
+			// X much longer than Y.
+			const X1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
+			const Y1 = [ 2, 5 ];
+			const result1 = shortestCommonSupersequence( X1, Y1 );
+
+			// Result should be same as X since Y is a subsequence.
+			expect( result1 ).toEqual( X1 );
+
+			// Y much longer than X.
+			const X2 = [ 2, 5 ];
+			const Y2 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
+			const result2 = shortestCommonSupersequence( X2, Y2 );
+
+			// Result should be same as Y since X is a subsequence.
+			expect( result2 ).toEqual( Y2 );
+		} );
+	} );
+
+	describe( 'Order preservation', () => {
+		it( 'should preserve order of elements from input arrays', () => {
+			const X = [ 1, 3, 5 ];
+			const Y = [ 5, 3, 1 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Verify optimal length.
+			expect( result.length ).toBe( 5 );
+
+			// Test reverse case.
+			const result2 = shortestCommonSupersequence( Y, X );
+			expect( isSubsequence( X, result2 ) ).toBe( true );
+			expect( isSubsequence( Y, result2 ) ).toBe( true );
+
+			// Verify optimal length.
+			expect( result2.length ).toBe( 5 );
+		} );
+
+		it( 'should handle zigzag patterns correctly', () => {
+			const X = [ 1, 3, 5, 7, 9 ];
+			const Y = [ 2, 4, 6, 8, 10 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Verify it's a valid supersequence.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Verify optimal length (should be X.length + Y.length because no common elements).
+			expect( result.length ).toBe( 10 );
+		} );
+	} );
+
+	describe( 'Advanced cases', () => {
+		it( 'should handle complex interleavings', () => {
+			const X = [ 1, 2, 3, 1, 2, 3 ];
+			const Y = [ 3, 2, 1, 3, 2, 1 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Result should be a valid supersequence.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Verify optimal length.
+			expect( result.length ).toBe( 9 );
+		} );
+
+		it( 'should handle almost identical arrays with one difference', () => {
+			const X = [ 1, 2, 3, 4, 5 ];
+			const Y = [ 1, 2, 3, 5, 4 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Result should contain 6 elements (optimal length).
+			expect( result.length ).toBe( 6 );
+
+			// The first 3 elements should be 1,2,3.
+			expect( result.slice( 0, 3 ) ).toEqual( [ 1, 2, 3 ] );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+		} );
+
+		it( 'should handle multiple matching possibilities optimally', () => {
+			const X = [ 1, 1, 2, 2 ];
+			const Y = [ 1, 2, 1, 2 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Result should be a valid supersequence.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Verify optimal length.
+			expect( result.length ).toBe( 5 );
+		} );
+	} );
+
+	describe( 'Custom equality function', () => {
+		it( 'should use custom equality function for comparing elements', () => {
+			const X = [
+				{ id: 1, name: 'a' },
+				{ id: 2, name: 'b' },
+			];
+			const Y = [
+				{ id: 1, name: 'c' },
+				{ id: 2, name: 'd' },
+			];
+
+			// Custom equality function that only compares 'id' property.
+			const isEqual = ( a, b ) => a.id === b.id;
+
+			const result = shortestCommonSupersequence( X, Y, isEqual );
+
+			// Should treat objects with same ids as equal.
+			expect( result.length ).toBe( 2 );
+			expect( result[ 0 ].id ).toBe( 1 );
+			expect( result[ 1 ].id ).toBe( 2 );
+
+			// Should use references from X.
+			expect( result[ 0 ] ).toBe( X[ 0 ] );
+			expect( result[ 1 ] ).toBe( X[ 1 ] );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result, isEqual ) ).toBe( true );
+			expect( isSubsequence( Y, result, isEqual ) ).toBe( true );
+		} );
+
+		it( 'should handle case-insensitive comparison', () => {
+			const X = [ 'A', 'B', 'C' ];
+			const Y = [ 'a', 'b', 'D' ];
+
+			// Case-insensitive comparison.
+			const isEqual = ( a, b ) => a.toLowerCase() === b.toLowerCase();
+
+			const result = shortestCommonSupersequence( X, Y, isEqual );
+
+			// Check references are from X when elements are considered equal.
+			expect( result[ 0 ] ).toBe( X[ 0 ] ); // 'A' instead of 'a'
+			expect( result[ 1 ] ).toBe( X[ 1 ] ); // 'B' instead of 'b'
+
+			// Verify it contains C and D (which don't match).
+			expect( result.includes( 'C' ) ).toBe( true );
+			expect( result.includes( 'D' ) ).toBe( true );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result, isEqual ) ).toBe( true );
+			expect( isSubsequence( Y, result, isEqual ) ).toBe( true );
+
+			// Check length is correct (4 instead of 6).
+			expect( result.length ).toBe( 4 );
+		} );
+	} );
+
+	describe( 'Null and undefined handling', () => {
+		it( 'should handle arrays with null values', () => {
+			const X = [ 1, null, 3 ];
+			const Y = [ null, 2, 3 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Should treat null values correctly.
+			expect( result ).toEqual( [ 1, null, 2, 3 ] );
+		} );
+
+		it( 'should handle arrays with undefined', () => {
+			const X = [ 1, undefined, 3 ];
+			const Y = [ 2, undefined, 4 ];
+			const result = shortestCommonSupersequence( X, Y );
+
+			// Test that it's a valid supersequence of both arrays.
+			expect( isSubsequence( X, result ) ).toBe( true );
+			expect( isSubsequence( Y, result ) ).toBe( true );
+
+			// Length should be shorter than concatenating the arrays.
+			expect( result.length ).toBeLessThan( X.length + Y.length );
+		} );
+	} );
+
+	describe( 'Mutation checks', () => {
+		it( 'should not modify the input arrays', () => {
+			const X = [ 1, 2, 3 ];
+			const Y = [ 2, 3, 4 ];
+
+			// Create copies for comparison.
+			const originalX = [ ...X ];
+			const originalY = [ ...Y ];
+
+			shortestCommonSupersequence( X, Y );
+
+			// Input arrays should remain unchanged.
+			expect( X ).toEqual( originalX );
+			expect( Y ).toEqual( originalY );
+		} );
+	} );
+} );