Tests for shortestCommonSupersequence (claude)

Author: luisherranz

packages/interactivity-router/src/assets/test/scs/scs.test.ts

@@ -0,0 +1,380 @@
+/**
+ * Internal dependencies
+ */
+import { shortestCommonSupersequence } from '../../scs';
+
+describe( 'shortestCommonSupersequence', () => {
+	// BASIC FUNCTIONALITY TESTS
+	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,
+			] );
+
+			// Should be the same reference from X when elements are identical
+			const result = shortestCommonSupersequence( X, Y );
+			expect( result[ 0 ] ).toBe( X[ 0 ] );
+			expect( result[ 1 ] ).toBe( X[ 1 ] );
+			expect( result[ 2 ] ).toBe( X[ 2 ] );
+		} );
+
+		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 );
+
+			// Result should contain all elements from both X and Y
+			expect( result ).toContain( 1 );
+			expect( result ).toContain( 2 );
+			expect( result ).toContain( 3 );
+			expect( result ).toContain( 4 );
+			expect( result ).toContain( 5 );
+			expect( result ).toContain( 6 );
+
+			// 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 );
+
+			// Result should be [1,2,3,4] with length 4, shorter than X.length + Y.length = 6
+			expect( result.length ).toBe( 4 );
+			expect( result ).toEqual( [ 1, 2, 3, 4 ] );
+		} );
+	} );
+
+	// EDGE CASES
+	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 ]
+			);
+
+			// Result should preserve order and contain all elements
+			expect( result.length ).toBeLessThanOrEqual( 8 ); // Maximum length would be 8
+
+			// Verify it's a valid supersequence by checking subsequences
+			expect( isSubsequence( [ 1, 2, 1, 2 ], result ) ).toBe( true );
+			expect( isSubsequence( [ 2, 1, 2, 1 ], result ) ).toBe( true );
+		} );
+
+		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 );
+		} );
+	} );
+
+	// ORDERING TESTS
+	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 );
+
+			// The algorithm should produce a result shorter than X.length + Y.length
+			expect( result.length ).toBeLessThanOrEqual( X.length + Y.length );
+
+			// Test reverse case
+			const result2 = shortestCommonSupersequence( Y, X );
+			expect( isSubsequence( X, result2 ) ).toBe( true );
+			expect( isSubsequence( Y, result2 ) ).toBe( true );
+		} );
+
+		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 );
+
+			// Verify all elements are present
+			X.concat( Y ).forEach( ( elem ) => {
+				expect( result ).toContain( elem );
+			} );
+		} );
+	} );
+
+	// ADVANCED CASES
+	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 );
+
+			// Result should be shorter than X.length + Y.length
+			expect( result.length ).toBeLessThan( X.length + Y.length );
+		} );
+
+		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 ] );
+		} );
+
+		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 );
+
+			// Length should be less than or equal to 6 (optimal)
+			expect( result.length ).toBeLessThanOrEqual( 6 );
+		} );
+	} );
+
+	// CUSTOM EQUALITY FUNCTION TESTS
+	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 ] );
+		} );
+
+		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 );
+
+			// Check length is correct (4 instead of 6)
+			expect( result.length ).toBe( 4 );
+		} );
+	} );
+
+	// NULL/UNDEFINED HANDLING
+	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 );
+
+			// Should handle undefined values correctly
+			expect( result ).toContain( 1 );
+			expect( result ).toContain( undefined );
+			expect( result ).toContain( 2 );
+			expect( result ).toContain( 3 );
+			expect( result ).toContain( 4 );
+
+			// Length should be shorter than concatenating the arrays
+			expect( result.length ).toBeLessThan( X.length + Y.length );
+		} );
+	} );
+
+	// MUTATION TESTS
+	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 );
+		} );
+	} );
+} );
+
+// Helper functions for testing
+function isSubsequence( arr, superseq ) {
+	let i = 0;
+	let j = 0;
+
+	while ( i < arr.length && j < superseq.length ) {
+		if ( arr[ i ] === superseq[ j ] ) {
+			i++;
+		}
+		j++;
+	}
+
+	return i === arr.length;
+}
+
+function findLastIndex( arr, predicate ) {
+	for ( let i = arr.length - 1; i >= 0; i-- ) {
+		if ( predicate( arr[ i ] ) ) {
+			return i;
+		}
+	}
+	return -1;
+}