Unit Testing

Our First Program: Binary Search Problem Statement: Write a function that consumes (1) a number to search for, and (2) an array of numbers sorted in ascending order. The function should produce true if the array contains the number and false if it does not. Examples: search(5, [2, 5]) // produces true search(4, [2, 5]) // produces false search(7, [2, 5, 7]) // produces true Type Signature: // search(v: number, a: number[]): boolean function search(v, a) { // TODO } function name argument name and type result type You should write the type of functions in a comment. It helps plan your code.

Step 1: Recursive pattern // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { // FILL } else { }

Step 2: Fill in base-case // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { // FILL } If the length of the array is 0, then there are no values in the array.

Step 4: Compare v to the middle element // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { let mid = a.length / 2; if (a[mid] === v) { return true; } else if (a[mid] > v) { // FILL } else /* a[mid] < v */ { } Three cases: the value in the middle is equal

Step 5: Fill in recursive cases // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { let mid = a.length / 2; if (a[mid] === v) { return true; } else if (a[mid] > v) { return search(v, a.slice(0, mid)); } else /* a[mid] < v */ { return search(v, a.slice(mid + 1, a.length)); } Note: a.slice method

Testing // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { let mid = a.length / 2; if (a[mid] === v) { return true; } else if (a[mid] > v) { return search(v, a.slice(0, mid)); } else /* a[mid] < v */ { return search(v, a.slice(mid + 1, a.length)); } Do both these test cases work? search(5, [2, 5]) search(5, [2, 5, 8]) JavaScript does not have integer division: > 3 / 2 1.5

Bug fix // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { let mid = Math.floor(a.length / 2); if (a[mid] === v) { return true; } else if (a[mid] > v) { return search(v, a.slice(0, mid)); } else /* a[mid] < v */ { return search(v, a.slice(mid + 1, a.length)); } These tests now work search(5, [2, 5]) search(5, [2, 5, 8]) Should we write more tests? Why not? More is better, right? Better question: do our tests cover all cases?

Test Coverage // search(v: number, a: number[]): boolean function search(v, a) { // Since the length of the array is unknown, // we will recur on the length of a. if (a.length === 0) { return false; } else { let mid = Math.floor(a.length / 2); if (a[mid] === v) { return true; } else if (a[mid] > v) { } else /* a[mid] < v */ { } This implementation is obvious broken. But, these tests still work. search(5, [2, 5]) search(5, [2, 5, 8]) The problem is that the wrong lines of code are not executed. Think of length-3 arrays that: Execute the wrong lines and pass. These tests are not informative. Execute the wrong lines and fail. These tests are informative and reveal actual bugs. search(5, [1, 2, 3]); search(5, [1, 2, 5]);

(Some) Lessons About Testing May need multiple test cases Question: How many? Tests should check execution in all branches of code This is called test coverage Tests should be informative Not executing the intended branches of code leads to incorrect results

Testing with Ocelot Name of the test Body of the test test("Empty list", function() { let a = []; assert(search(1, a) === false); }); test("Mid match", function() { let a = [1, 4, 5]; assert(search(4, a) === true); test("Search upper half", function() { assert(search(5, a) === true); assert(search(4.5, a) === false); assert(search(7, a) === false); Name of the test Body of the test This is an anonymous function. We will study them in detail very soon. Assertions succeed only if provided a boolean expression that is true Can have multiple assertions

Mini-Program: Comparing Arrays Problem Statement: Write a function that consumes two arrays of numbers. The function should produce true if the arrays have exactly the same values in-order, and otherwise false. Examples: arrayEqual([1, 2], [1, 2]) // produces true arrayEqual([1, 2], [2, 1]) // produces false arrayEqual([1, 2], [1, 2, 3]) // produces false Type Signature: // arrayEqual(a1: number[], a2: number[]): boolean function arrayEqual(a1, a2) { // TODO }

Mini-Program: Comparing Arrays This will not work: // arrayEqual(a1: number[], a2: number[]): boolean function arrayEqual(a1, a2) { return a1 === a2; } Why? It compares references to the arrays, rather than the contents of the arrays. We will explore this in detail in lecture 7. Q: What properties should two arrays have, to declare that they are “equal”?

Mini-Program: Comparing Arrays // arrayEqual(a1: number[], a2: number[]): boolean function arrayEqual(a1, a2) { if (a1.length !== a2.length) { return false; } for (let i = 0; i< a1.length; ++i) { if (a1[i] !== a2[i]) { return true; Q: What cases should we use to test this?

Mini-Program: Comparing Arrays test("empty arrays", function() { assert(arrayEqual([], []) == true); }); test("unequal lengths", function() { assert(arrayEqual([1, 2], [1, 2, 3]) == false); assert(arrayEqual([2, 3], [1, 2, 3]) == false); test("equal lengths", function() { assert(arrayEqual([1, 2], [1, 2]) == true); assert(arrayEqual([1, 2], [2, 3]) == false);

Mini-Program: rootMagnitude Problem Statement: Write a function that consumes an array of numbers and produces an array of numbers. Each element of the output array should be the square-root of the corresponding element in the output array, but with the same sign. Examples: Warning: Math.sqrt produces NaN when applied to a negative number! rootMagnitude([4, 9]) // produces [2, 3] rootMagnitude([0.16, 2.56]) // [0.4, 1.6] rootMagnitude([-16, -25, -100]) // [-4, -5, -10] rootMagnitude([4, -9]) // [2, -3] Type Signature: // rootMagnitude(a: number[]): number[] function rootMagnitude(a1, a2) { // TODO }

Attempt 1: update the array in-place // rootMagnitude(a: number[]): number[] function rootMagnitude(a) { for (let i = 0; i < a.length; ++i) { if (a[i] >= 0) { a[i] = Math.sqrt(a[i]); } else { // TODO } return a; test("Test rootMagnitude", function() { assert(arrayEqual(rootMagnitude([4, 9]), [2, 3])); assert(arrayEqual(rootMagnitude([16, 100]), [4, 10])); }); We need a test case to execute this branch. Updating the array in Note: We use arrayEqual to compare the arrays.

Attempt 1: update the array in-place // rootMagnitude(a: number[]): number[] function rootMagnitude(a) { for (let i = 0; i < a.length; ++i) { if (a[i] >= 0) { a[i] = Math.sqrt(a[i]); } else { a[i] = a[i]; } return a; test("negative elements", function() { assert(arrayEqual(rootMagnitude([4, -1]), [2, -1])); }); The test passes! But, the implementation in obviously wrong. Updating the array in The problem is we are updating the array in-place, so the input and output are identically. Rule of thumb: do not update arrays in-place

Attempt 2: produce a new array // rootMagnitude(a: number[]): number[] function rootMagnitude(a) { let b = []; for (let i = 0; i < a.length; ++i) { if (a[i] >= 0) { b.push(Math.sqrt(a[i])); } else { b.push(-Math.sqrt(-a[i])); } return b; test("negative elements", function() { assert(arrayEqual(rootMagnitude([4, -1]), [2, -1])); }); Note: .push method of arrays adds an element to the end. Arrays in JavaScript are similar to ArrayLists in Java. Updating the array in

(Some) Lessons About Testing May need multiple test cases Question: How many? Tests should check execution in all branches of code This is called test coverage Tests should be informative Not executing the intended branches of code leads to incorrect results Tests may need additional test infrastructure e.g. arrayEqual()