Unit Testing Our First Program Binary Search Problem

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 { // FILL } }

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 */ { // FILL } } } 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]) Java. Script 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) { return false; } else /* a[mid] < v */ { return false; } } } 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: 1. Execute the wrong lines and pass. These tests are not informative. search(5, [1, 2, 3]); 2. Execute the wrong lines and fail. These tests are informative and reveal actual bugs. search(5, [1, 2, 5]);

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

Testing with Ocelot 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() { let a = [1, 4, 5]; 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: array. Equal([1, 2], [1, 2]) // produces true array. Equal([1, 2], [2, 1]) // produces false array. Equal([1, 2], [1, 2, 3]) // produces false Type Signature: // array. Equal(a 1: number[], a 2: number[]): boolean function array. Equal(a 1, a 2) { // TODO }

Mini-Program: Comparing Arrays This will not work: // array. Equal(a 1: number[], a 2: number[]): boolean function array. Equal(a 1, a 2) { return a 1 === a 2; } 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 // array. Equal(a 1: number[], a 2: number[]): boolean function array. Equal(a 1, a 2) { if (a 1. length !== a 2. length) { return false; } for (let i = 0; i< a 1. length; ++i) { if (a 1[i] !== a 2[i]) { return false; } } return true; } Q: What cases should we use to test this?

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

Mini-Program: root. Magnitude 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: root. Magnitude([4, 9]) // produces [2, 3] root. Magnitude([0. 16, 2. 56]) // [0. 4, 1. 6] root. Magnitude([-16, -25, -100]) // [-4, -5, -10] root. Magnitude([4, -9]) // [2, -3] Type Signature: // root. Magnitude(a: number[]): number[] function root. Magnitude(a 1, a 2) { // TODO } Warning: Math. sqrt produces Na. N when applied to a negative number!

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

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

Attempt 2: produce a new array // root. Magnitude(a: number[]): number[] function root. Magnitude(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(array. Equal(root. Magnitude([4, -1]), [2, -1])); }); Note: . push method of arrays adds an element to the end. Arrays in Java. Script are similar to Array. Lists in Java.

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