Implementing a Test Oracle in Jest for Array Sorting

Writing robust tests often involves verifying not just that a function runs without errors, but also that it produces the correct output. A test oracle is a mechanism that determines the expected output for a given input, allowing Jest to accurately assess the correctness of your code. This challenge focuses on creating a test oracle for a function that sorts an array of numbers.

Problem Description

You are given a function sortArray(arr: number[]): number[] that is intended to sort an array of numbers in ascending order. Your task is to implement a test oracle – a separate function – that, given an input array, calculates the expected sorted array. This oracle will then be used in your Jest tests to compare against the actual output of sortArray. The oracle should be independent of the sorting algorithm used by sortArray.

Key Requirements:

• The oracle must correctly determine the expected sorted array for any given input array of numbers.
• The oracle should handle edge cases such as empty arrays, arrays with duplicate numbers, and arrays with negative numbers.
• The oracle should be efficient enough to not significantly slow down the test suite.

Expected Behavior:

The oracle function, createExpectedSortedArray(arr: number[]): number[], should take an array of numbers as input and return a new array containing the same numbers, sorted in ascending order.

Edge Cases to Consider:

• Empty array: [] should return [].
• Array with one element: [5] should return [5].
• Array with duplicate numbers: [3, 1, 3, 2] should return [1, 2, 3, 3].
• Array with negative numbers: [-2, 1, 0, -5] should return [-5, -2, 0, 1].
• Array with mixed positive, negative, and zero values: [-1, 0, 2, -3, 1] should return [-3, -1, 0, 1, 2].

Examples

Example 1:

Input: [3, 1, 4, 1, 5, 9, 2, 6]
Output: [1, 1, 2, 3, 4, 5, 6, 9]
Explanation: The input array is sorted in ascending order.

Example 2:

Input: [-2, 1, 0, -5]
Output: [-5, -2, 0, 1]
Explanation: The input array, containing negative numbers, is sorted in ascending order.

Example 3:

Input: []
Output: []
Explanation: An empty array remains empty after sorting.

Constraints

• The input array arr will contain only numbers (integers or floating-point numbers).
• The oracle function must return a new array; it should not modify the original input array.
• The time complexity of the oracle should be O(n log n), where n is the length of the input array. While a simpler O(n^2) solution is acceptable for this exercise, consider the performance implications for larger arrays.

Notes

• You are not required to implement the sortArray function itself. Your focus is solely on creating the test oracle, createExpectedSortedArray.
• You can use any standard JavaScript/TypeScript sorting algorithm within the oracle (e.g., Array.prototype.sort()).
• The Jest tests will use this oracle to compare the output of sortArray with the expected sorted array. Think about how the oracle's correctness directly impacts the reliability of your tests.
• Consider using a spread operator (...) to create a copy of the input array before sorting to avoid modifying the original array. This is good practice for test stability.