update tests, multiple exercises

caesar/caesar.spec.js

@@ -1,26 +1,23 @@
-const expect = require('expect');
 const caesar = require('./caesar')
 
-describe('caesar', function() {
+test('works with single letters', () => {
-  test('works with single letters', function() {
+  expect(caesar('A', 1)).toBe('B');
-    expect(caesar('A', 1)).toBe('B');
+});
-  });
+test.skip('works with words', () => {
-  test.skip('works with words', function() {
+  expect(caesar('Aaa', 1)).toBe('Bbb');
-    expect(caesar('Aaa', 1)).toBe('Bbb');
+});
-  });
+test.skip('works with phrases', () => {
-  test.skip('works with phrases', function() {
+  expect(caesar('Hello, World!', 5)).toBe('Mjqqt, Btwqi!');
-    expect(caesar('Hello, World!', 5)).toBe('Mjqqt, Btwqi!');
+});
-  });
+test.skip('works with negative shift', () => {
-  test.skip('works with negative shift', function() {
+  expect(caesar('Mjqqt, Btwqi!', -5)).toBe('Hello, World!');
-    expect(caesar('Mjqqt, Btwqi!', -5)).toBe('Hello, World!');
+});
-  });
+test.skip('wraps', () => {
-  test.skip('wraps', function() {
+  expect(caesar('Z', 1)).toBe('A');
-    expect(caesar('Z', 1)).toBe('A');
+});
-  });
+test.skip('works with large shift factors', () => {
-  test.skip('works with large shift factors', function() {
+  expect(caesar('Hello, World!', 75)).toBe('Ebiil, Tloia!');
-    expect(caesar('Hello, World!', 75)).toBe('Ebiil, Tloia!');
+});
-  });
+test.skip('works with large negative shift factors', () => {
-  test.skip('works with large negative shift factors', function() {
+  expect(caesar('Hello, World!', -29)).toBe('Ebiil, Tloia!');
-    expect(caesar('Hello, World!', -29)).toBe('Ebiil, Tloia!');
-  });
 });

calculator/calculator.spec.js

@@ -1,77 +1,77 @@
-const expect = require('expect');const calculator = require ('./calculator.js');
+const calculator = require ('./calculator.js');
 
-describe('add', function() {
+describe('add', () => {
-	it('adds 0 and 0', function() {
+	test('adds 0 and 0', () => {
-		expect(calculator.add(0,0)).toEqual(0);
+		expect(calculator.add(0,0)).toBe(0);
 	});
 
-	xit('adds 2 and 2', function() {
+	test.skip('adds 2 and 2', () => {
-		expect(calculator.add(2,2)).toEqual(4);
+		expect(calculator.add(2,2)).toBe(4);
 	});
 
-	xit('adds positive numbers', function() {
+	test.skip('adds positive numbers', () => {
-		expect(calculator.add(2,6)).toEqual(8);
+		expect(calculator.add(2,6)).toBe(8);
 	});
 });
 
-describe('subtract', function() {
+describe('subtract', () => {
-	xit('subtracts numbers', function() {
+	test.skip('subtracts numbers', () => {
-		expect(calculator.subtract(10,4)).toEqual(6);
+		expect(calculator.subtract(10,4)).toBe(6);
 	});
 });
 
-describe('sum', function() {
+describe('sum', () => {
-	xit('computes the sum of an empty array', function() {
+	test.skip('computes the sum of an empty array', () => {
-		expect(calculator.sum([])).toEqual(0);
+		expect(calculator.sum([])).toBe(0);
 	});
 
-	xit('computes the sum of an array of one number', function() {
+	test.skip('computes the sum of an array of one number', () => {
-		expect(calculator.sum([7])).toEqual(7);
+		expect(calculator.sum([7])).toBe(7);
 	});
 
-	xit('computes the sum of an array of two numbers', function() {
+	test.skip('computes the sum of an array of two numbers', () => {
-		expect(calculator.sum([7,11])).toEqual(18);
+		expect(calculator.sum([7,11])).toBe(18);
 	});
 
-	xit('computes the sum of an array of many numbers', function() {
+	test.skip('computes the sum of an array of many numbers', () => {
-		expect(calculator.sum([1,3,5,7,9])).toEqual(25);
+		expect(calculator.sum([1,3,5,7,9])).toBe(25);
 	});
 });
 
-describe('multiply', function() {
+describe('multiply', () => {
-	xit('multiplies two numbers', function() {
+	test.skip('multiplies two numbers', () => {
-		expect(calculator.multiply([2,4])).toEqual(8);
+		expect(calculator.multiply([2,4])).toBe(8);
 	});
 
-	xit('multiplies several numbers', function() {
+	test.skip('multiplies several numbers', () => {
-		expect(calculator.multiply([2,4,6,8,10,12,14])).toEqual(645120);
+		expect(calculator.multiply([2,4,6,8,10,12,14])).toBe(645120);
 	});
 });
 
-describe('power', function() {
+describe('power', () => {
-	xit('raises one number to the power of another number', function() {
+	test.skip('raises one number to the power of another number', () => {
-		expect(calculator.power(4,3)).toEqual(64); // 4 to third power is 64
+		expect(calculator.power(4,3)).toBe(64); // 4 to third power is 64
 	});
 });
 
-describe('factorial', function() {
+describe('factorial', () => {
-	xit('computes the factorial of 0', function() {
+	test.skip('computes the factorial of 0', () => {
-		expect(calculator.factorial(0)).toEqual(1); // 0! = 1
+		expect(calculator.factorial(0)).toBe(1); // 0! = 1
 	});
 
-	xit('computes the factorial of 1', function() {
+	test.skip('computes the factorial of 1', () => {
-		expect(calculator.factorial(1)).toEqual(1);
+		expect(calculator.factorial(1)).toBe(1);
 	});
 
-	xit('computes the factorial of 2', function() {
+	test.skip('computes the factorial of 2', () => {
-		expect(calculator.factorial(2)).toEqual(2);
+		expect(calculator.factorial(2)).toBe(2);
 	});
 
-	xit('computes the factorial of 5', function() {
+	test.skip('computes the factorial of 5', () => {
-		expect(calculator.factorial(5)).toEqual(120);
+		expect(calculator.factorial(5)).toBe(120);
 	});
 
-	xit('computes the factorial of 10', function() {
+	test.skip('computes the factorial of 10', () => {
-		expect(calculator.factorial(10)).toEqual(3628800);
+		expect(calculator.factorial(10)).toBe(3628800);
 	});
 });

fibonacci/fibonacci.spec.js

@@ -1,31 +1,31 @@
-const expect = require('expect');const fibonacci = require('./fibonacci')
+const fibonacci = require('./fibonacci')
 
-describe('fibonacci', function() {
+describe('fibonacci', () => {
-  it('works', function() {
+  test('4th fibonacci number is 3', () => {
-    expect(fibonacci(4)).toEqual(3);
+    expect(fibonacci(4)).toBe(3);
   });
-  xit('works', function() {
+  test.skip('6th fibonacci number is 8', () => {
-    expect(fibonacci(6)).toEqual(8);
+    expect(fibonacci(6)).toBe(8);
   });
-  xit('works', function() {
+  test.skip('10th fibonacci number is 55', () => {
-    expect(fibonacci(10)).toEqual(55);
+    expect(fibonacci(10)).toBe(55);
   });
-  xit('works', function() {
+  test.skip('15th fibonacci number is 610', () => {
-    expect(fibonacci(15)).toEqual(610);
+    expect(fibonacci(15)).toBe(610);
   });
-  xit('works', function() {
+  test.skip('25th fibonacci number is 75025', () => {
-    expect(fibonacci(25)).toEqual(75025);
+    expect(fibonacci(25)).toBe(75025);
   });
-  xit('doesn\'t accept negatives', function() {
+  test.skip('doesn\'t accept negatives', () => {
-    expect(fibonacci(-25)).toEqual("OOPS");
+    expect(fibonacci(-25)).toBe("OOPS");
   });
-  xit('DOES accept strings', function() {
+  test.skip('DOES accept strings', () => {
-    expect(fibonacci("1")).toEqual(1);
+    expect(fibonacci("1")).toBe(1);
   });
-  xit('DOES accept strings', function() {
+  test.skip('DOES accept strings', () => {
-    expect(fibonacci("2")).toEqual(1);
+    expect(fibonacci("2")).toBe(1);
   });
-  xit('DOES accept strings', function() {
+  test.skip('DOES accept strings', () => {
-    expect(fibonacci("8")).toEqual(21);
+    expect(fibonacci("8")).toBe(21);
   });
 });

findTheOldest/findTheOldest.spec.js

@@ -1,7 +1,7 @@
-const expect = require('expect');let findTheOldest = require('./findTheOldest')
+const findTheOldest = require('./findTheOldest')
 
-describe('findTheOldest', function() {
+describe('findTheOldest', () => {
-  it('finds the oldest person!', function() {
+  test('finds the oldest person!', () => {
     const people = [
       {
         name: 'Carly',
@@ -19,9 +19,9 @@ describe('findTheOldest', function() {
         yearOfDeath: 1941
       },
     ]
-    expect(findTheOldest(people).name).toEqual('Ray');
+    expect(findTheOldest(people).name).toBe('Ray');
   });
-  xit('finds the oldest person if someone is still living', function() {
+  test.skip('finds the oldest person if someone is still living', () => {
     const people = [
       {
         name: 'Carly',
@@ -38,9 +38,9 @@ describe('findTheOldest', function() {
         yearOfDeath: 1941
       },
     ]
-    expect(findTheOldest(people).name).toEqual('Ray');
+    expect(findTheOldest(people).name).toBe('Ray');
   });
-  xit('finds the oldest person if the OLDEST is still living', function() {
+  test.skip('finds the oldest person if the OLDEST is still living', () => {
     const people = [
       {
         name: 'Carly',
@@ -57,7 +57,7 @@ describe('findTheOldest', function() {
         yearOfDeath: 1941
       },
     ]
-    expect(findTheOldest(people).name).toEqual('Carly');
+    expect(findTheOldest(people).name).toBe('Carly');
   });
 
 });

getTheTitles/getTheTitles.spec.js

@@ -1,6 +1,6 @@
-const expect = require('expect');let getTheTitles = require('./getTheTitles')
+const getTheTitles = require('./getTheTitles')
 
-describe('getTheTitles', function() {
+describe('getTheTitles', () => {
     const books = [
       {
         title: 'Book',
@@ -12,8 +12,8 @@ describe('getTheTitles', function() {
       }
     ]
 
-  it('gets titles', function() {
+  test('gets titles', () => {
-    expect(getTheTitles(books)).toEqual(['Book','Book2']);
+    expect(getTheTitles(books)).toBe(['Book','Book2']);
   });
 
 });

helloWorld/helloWorld.js

@@ -1,5 +1,5 @@
 const helloWorld = function() {
-  return 'Yello Wold!'
+  return ''
 }
 
 module.exports = helloWorld;

helloWorld/helloWorld.spec.js

@@ -1,14 +1,5 @@
-const expect = require('expect');
 const helloWorld = require('./helloWorld');
 
-// describe('Hello World', function() {
+test('says "Hello, World!"', function() {
-//   it('says hello world', function() {
+  expect(helloWorld()).toBe("Hello, World!");
-//     expect(helloWorld()).toEqual('Hello, World!');
-//   });
-// });
-
-describe('helloWorld', function() {
-  test('says "Hello, World!"', function() {
-    expect(helloWorld()).toBe("Hello, World!");
-  })
 });

leapYears/leapYears.spec.js

@@ -1,23 +1,22 @@
-const expect = require('expect');
 const leapYears = require('./leapYears')
 
-describe('leapYears', function() {
+describe('leapYears', () => {
-  it('works with non century years', function() {
+  test('works with non century years', () => {
-    expect(leapYears(1996)).toEqual(true);
+    expect(leapYears(1996)).toBe(true);
   });
-  xit('works with non century years', function() {
+  test.skip('works with non century years', () => {
-    expect(leapYears(1997)).toEqual(false);
+    expect(leapYears(1997)).toBe(false);
   });
-  xit('works with ridiculously futuristic non century years', function() {
+  test.skip('works with ridiculously futuristic non century years', () => {
-    expect(leapYears(34992)).toEqual(true);
+    expect(leapYears(34992)).toBe(true);
   });
-  xit('works with century years', function() {
+  test.skip('works with century years', () => {
-    expect(leapYears(1900)).toEqual(false);
+    expect(leapYears(1900)).toBe(false);
   });
-  xit('works with century years', function() {
+  test.skip('works with century years', () => {
-    expect(leapYears(1600)).toEqual(true);
+    expect(leapYears(1600)).toBe(true);
   });
-  xit('works with century years', function() {
+  test.skip('works with century years', () => {
-    expect(leapYears(700)).toEqual(false);
+    expect(leapYears(700)).toBe(false);
   });
 });

palindromes/palindromes.spec.js

@@ -1,23 +1,23 @@
-const expect = require('expect');const palindromes = require('./palindromes')
+const palindromes = require('./palindromes')
 
-describe('palindromes', function() {
+describe('palindromes', () => {
-  it('works with single words', function() {
+  test('works with single words', () => {
-    expect(palindromes('racecar')).toEqual(true);
+    expect(palindromes('racecar')).toBe(true);
   });
-  xit('works with punctuation ', function() {
+  test.skip('works with punctuation ', () => {
-    expect(palindromes('racecar!')).toEqual(true);
+    expect(palindromes('racecar!')).toBe(true);
   });
-  xit('works with upper-case letters ', function() {
+  test.skip('works with upper-case letters ', () => {
-    expect(palindromes('Racecar!')).toEqual(true);
+    expect(palindromes('Racecar!')).toBe(true);
   });
-  xit('works with multiple words', function() {
+  test.skip('works with multiple words', () => {
-    expect(palindromes('A car, a man, a maraca.')).toEqual(true);
+    expect(palindromes('A car, a man, a maraca.')).toBe(true);
   });
-  xit('works with multiple words', function() {
+  test.skip('works with multiple words', () => {
-    expect(palindromes('Animal loots foliated detail of stool lamina.')).toEqual(true);
+    expect(palindromes('Animal loots foliated detail of stool lamina.')).toBe(true);
   });
-  xit('doesn\'t just always return true', function() {
+  test.skip('doesn\'t just always return true', () => {
-    expect(palindromes('ZZZZ car, a man, a maraca.')).toEqual(false);
+    expect(palindromes('ZZZZ car, a man, a maraca.')).toBe(false);
   });
 
 });

pig_latin/pigLatin.spec.js

@@ -1,15 +1,17 @@
-const expect = require("expect");//  Topics
+const expect = require("expect");
+
+//  Topics
 
 //  * modules
 //  * strings
 
 //  Pig Latin
 
-// Pig Latin is a made-up children's language that's intended to be confusing. It obeys a few simple rules (below) but when it's spoken quickly it's really difficult for non-children (and non-native speakers) to understand.
+// Pig Latin is a made-up children's language that's intended to be confusing. test obeys a few simple rules (below) but when test's spoken quickly test's really difficult for non-children (and non-native speakers) to understand.
 
 // Rule 1: If a word begins with a vowel sound, add an "ay" sound to the end of the word.
 
-// Rule 2: If a word begins with a consonant sound, move it to the end of the word, and then add an "ay" sound to the end of the word.
+// Rule 2: If a word begins with a consonant sound, move test to the end of the word, and then add an "ay" sound to the end of the word.
 
 // (There are a few more rules for edge cases, and there are regional variants too, but that should be enough to understand the tests.)
 
@@ -17,48 +19,48 @@ const expect = require("expect");//  Topics
 
 const pigLatin = require("./pigLatin.js");
 
-describe('#translate', function() {
+describe('translate', () => {
-	it('translates a word beginning with a vowel', function() {
+	test('translates a word beginning with a vowel', () => {
 		s = pigLatin.translate("apple");
-		expect(s).toEqual('appleay');
+		expect(s).toBe('appleay');
 	});
 
-	xit('translates a word beginning with a consonant', function() {
+	test.skip('translates a word beginning with a consonant', () => {
 		s = pigLatin.translate("banana");
-		expect(s).toEqual("ananabay");
+		expect(s).toBe("ananabay");
 	});
 
-	xit('translates a word beginning with two consonants', function() {
+	test.skip('translates a word beginning with two consonants', () => {
 		s = pigLatin.translate("cherry");
-		expect(s).toEqual('errychay');
+		expect(s).toBe('errychay');
 	});
 
-	xit('translates two words', function() {
+	test.skip('translates two words', () => {
 		s = pigLatin.translate("eat pie");
-		expect(s).toEqual('eatay iepay');
+		expect(s).toBe('eatay iepay');
 	});
 
-	xit('translates a word beginning with three consonants', function() {
+	test.skip('translates a word beginning with three consonants', () => {
-		expect(pigLatin.translate("three")).toEqual("eethray");
+		expect(pigLatin.translate("three")).toBe("eethray");
 	});
 
-	xit('counts "sch" as a single phoneme', function() {
+	test.skip('counts "sch" as a single phoneme', () => {
 		s = pigLatin.translate("school");
-		expect(s).toEqual("oolschay");
+		expect(s).toBe("oolschay");
 	});
 
-	xit('counts "qu" as a single phoneme', function() {
+	test.skip('counts "qu" as a single phoneme', () => {
 		s = pigLatin.translate("quiet");
-		expect(s).toEqual("ietquay");
+		expect(s).toBe("ietquay");
 	});
 
-	xit('counts "qu" as a consonant even when its preceded by a consonant', function() {
+	test.skip('counts "qu" as a consonant even when its preceded by a consonant', () => {
 		s = pigLatin.translate("square");
-		expect(s).toEqual("aresquay");
+		expect(s).toBe("aresquay");
 	});
 
-	xit('translates many words', function() {
+	test.skip('translates many words', () => {
 		s = pigLatin.translate("the quick brown fox");
-		expect(s).toEqual("ethay ickquay ownbray oxfay");
+		expect(s).toBe("ethay ickquay ownbray oxfay");
 	});
 });

removeFromArray/removeFromArray.spec.js

@@ -1,25 +1,25 @@
-const expect = require('expect');const removeFromArray = require('./removeFromArray')
+const removeFromArray = require('./removeFromArray')
 
-describe('removeFromArray', function() {
+describe('removeFromArray', () => {
-  it('removes a single value', function() {
+  test('removes a single value', () => {
-    expect(removeFromArray([1, 2, 3, 4], 3)).toEqual([1, 2, 4]);
+    expect(removeFromArray([1, 2, 3, 4], 3)).toBe([1, 2, 4]);
   });
-  xit('removes multiple values', function() {
+  test.skip('removes multiple values', () => {
-    expect(removeFromArray([1, 2, 3, 4], 3, 2)).toEqual([1, 4]);
+    expect(removeFromArray([1, 2, 3, 4], 3, 2)).toBe([1, 4]);
   });
-  xit('ignores non present values', function() {
+  test.skip('ignores non present values', () => {
-    expect(removeFromArray([1, 2, 3, 4], 7, "tacos")).toEqual([1, 2, 3, 4]);
+    expect(removeFromArray([1, 2, 3, 4], 7, "tacos")).toBe([1, 2, 3, 4]);
   });
-  xit('ignores non present values, but still works', function() {
+  test.skip('ignores non present values, but still works', () => {
-    expect(removeFromArray([1, 2, 3, 4], 7, 2)).toEqual([1, 3, 4]);
+    expect(removeFromArray([1, 2, 3, 4], 7, 2)).toBe([1, 3, 4]);
   });
-  xit('can remove all values', function() {
+  test.skip('can remove all values', () => {
-    expect(removeFromArray([1, 2, 3, 4], 1, 2, 3, 4)).toEqual([]);
+    expect(removeFromArray([1, 2, 3, 4], 1, 2, 3, 4)).toBe([]);
   });
-  xit('works with strings', function() {
+  test.skip('works with strings', () => {
-    expect(removeFromArray(["hey", 2, 3, "ho"], "hey", 3)).toEqual([2, "ho"]);
+    expect(removeFromArray(["hey", 2, 3, "ho"], "hey", 3)).toBe([2, "ho"]);
   });
-  xit('only removes same type', function() {
+  test.skip('only removes same type', () => {
-    expect(removeFromArray([1, 2, 3], "1", 3)).toEqual([1, 2]);
+    expect(removeFromArray([1, 2, 3], "1", 3)).toBe([1, 2]);
   });
 });