worked thru the koans exercise

koans/AboutArrays.js

@@ -1,58 +1,58 @@
 describe("About Arrays", function() {
 
-  //We shall contemplate truth by testing reality, via spec expectations.  
+  //We shall contemplate truth by testing reality, via spec expectations.
   it("should create arrays", function() {
     var emptyArray = [];
-    expect(typeof(emptyArray)).toBe(FILL_ME_IN); //A mistake? - http:javascript.crockford.com/remedial.html
-    expect(emptyArray.length).toBe(FILL_ME_IN);
+    expect(typeof(emptyArray)).toBe("object"); //A mistake? - http:javascript.crockford.com/remedial.html
+    expect(emptyArray.length).toBe(0);
 
     var multiTypeArray = [0, 1, "two", function () { return 3; }, {value1: 4, value2: 5}, [6, 7]];
-    expect(multiTypeArray[0]).toBe(FILL_ME_IN);
-    expect(multiTypeArray[2]).toBe(FILL_ME_IN);
-    expect(multiTypeArray[3]()).toBe(FILL_ME_IN);
-    expect(multiTypeArray[4].value1).toBe(FILL_ME_IN);
-    expect(multiTypeArray[4]["value2"]).toBe(FILL_ME_IN);
-    expect(multiTypeArray[5][0]).toBe(FILL_ME_IN);
+    expect(multiTypeArray[0]).toBe(0);
+    expect(multiTypeArray[2]).toBe("two");
+    expect(multiTypeArray[3]()).toBe(3);
+    expect(multiTypeArray[4].value1).toBe(4);
+    expect(multiTypeArray[4]["value2"]).toBe(5);
+    expect(multiTypeArray[5][0]).toBe(6);
   });
 
   it("should understand array literals", function () {
     var array = [];
     expect(array).toEqual([]);
-    
+
     array[0] = 1;
     expect(array).toEqual([1]);
-    
+
     array[1] = 2;
-    expect(array).toEqual([1, FILL_ME_IN]);
-    
+    expect(array).toEqual([1,2]);
+
     array.push(3);
-    expect(array).toEqual(FILL_ME_IN);
+    expect(array).toEqual([1,2,3]);
   });
 
   it("should understand array length", function () {
     var fourNumberArray = [1, 2, 3, 4];
 
-    expect(fourNumberArray.length).toBe(FILL_ME_IN);
+    expect(fourNumberArray.length).toBe(4);
     fourNumberArray.push(5, 6);
-    expect(fourNumberArray.length).toBe(FILL_ME_IN);
+    expect(fourNumberArray.length).toBe(6);
 
-    var tenEmptyElementArray = new Array(10); 
-    expect(tenEmptyElementArray.length).toBe(FILL_ME_IN);
+    var tenEmptyElementArray = new Array(10);
+    expect(tenEmptyElementArray.length).toBe(10);
 
     tenEmptyElementArray.length = 5;
-    expect(tenEmptyElementArray.length).toBe(FILL_ME_IN);
+    expect(tenEmptyElementArray.length).toBe(5);
   });
 
   it("should slice arrays", function () {
     var array = ["peanut", "butter", "and", "jelly"];
-    
-    expect(array.slice(0, 1)).toEqual(FILL_ME_IN);
-    expect(array.slice(0, 2)).toEqual(FILL_ME_IN);
-    expect(array.slice(2, 2)).toEqual(FILL_ME_IN);
-    expect(array.slice(2, 20)).toEqual(FILL_ME_IN);
-    expect(array.slice(3, 0)).toEqual(FILL_ME_IN);
-    expect(array.slice(3, 100)).toEqual(FILL_ME_IN);
-    expect(array.slice(5, 1)).toEqual(FILL_ME_IN);
+
+    expect(array.slice(0, 1)).toEqual(["peanut"]);
+    expect(array.slice(0, 2)).toEqual(["peanut","butter"]);
+    expect(array.slice(2, 2)).toEqual([]);
+    expect(array.slice(2, 20)).toEqual(["and","jelly"]);
+    expect(array.slice(3, 0)).toEqual([]);
+    expect(array.slice(3, 100)).toEqual(["jelly"]);
+    expect(array.slice(5, 1)).toEqual([]);
   });
 
   it("should know array references", function () {
@@ -62,36 +62,36 @@ describe("About Arrays", function() {
       refArray[1] = "changed in function";
     }
     passedByReference(array);
-    expect(array[1]).toBe(FILL_ME_IN);
+    expect(array[1]).toBe("changed in function");
 
     var assignedArray = array;
     assignedArray[5] = "changed in assignedArray";
-    expect(array[5]).toBe(FILL_ME_IN);
+    expect(array[5]).toBe("changed in assignedArray");
 
     var copyOfArray = array.slice();
     copyOfArray[3] = "changed in copyOfArray";
-    expect(array[3]).toBe(FILL_ME_IN);
+    expect(array[3]).toBe("three");
   });
 
   it("should push and pop", function () {
     var array = [1, 2];
     array.push(3);
 
-    expect(array).toEqual(FILL_ME_IN);
-    
+    expect(array).toEqual([1,2,3]);
+
     var poppedValue = array.pop();
-    expect(poppedValue).toBe(FILL_ME_IN);
-    expect(array).toEqual(FILL_ME_IN);
+    expect(poppedValue).toBe(3);
+    expect(array).toEqual([1,2]);
   });
 
   it("should know about shifting arrays", function () {
     var array = [1, 2];
 
     array.unshift(3);
-    expect(array).toEqual(FILL_ME_IN);
-    
+    expect(array).toEqual([3,1,2]);
+
     var shiftedValue = array.shift();
-    expect(shiftedValue).toEqual(FILL_ME_IN);
-    expect(array).toEqual(FILL_ME_IN);
-  });  
+    expect(shiftedValue).toEqual(3);
+    expect(array).toEqual([1,2]);
+  });
 });

koans/AboutExpects.js

@@ -1,38 +1,38 @@
 describe("About Expects", function() {
 
-  //We shall contemplate truth by testing reality, via spec expectations.  
+  //We shall contemplate truth by testing reality, via spec expectations.
   it("should expect true", function() {
-    expect(false).toBeTruthy(); //This should be true
+    expect(true).toBeTruthy(); //This should be true
   });
 
   //To understand reality, we must compare our expectations against reality.
-  it("should expect equality", function () { 
-	  var expectedValue = FILL_ME_IN;
-	  var actualValue = 1 + 1;
-	
+  it("should expect equality", function () {
+	  var expectedValue = actualValue;
+	  var actualValue = expectedValue;
+
 	  expect(actualValue === expectedValue).toBeTruthy();
-  });  
+  });
 
   //Some ways of asserting equality are better than others.
-  it("should assert equality a better way", function () { 
-	  var expectedValue = FILL_ME_IN;
-	  var actualValue = 1 + 1;
-	
+  it("should assert equality a better way", function () {
+	  var expectedValue = actualValue;
+	  var actualValue = expectedValue;
+
   // toEqual() compares using common sense equality.
 	  expect(actualValue).toEqual(expectedValue);
   });
 
   //Sometimes you need to be really exact about what you "type".
-  it("should assert equality with ===", function () { 
-	  var expectedValue = FILL_ME_IN;
-	  var actualValue = (1 + 1).toString();
-	
+  it("should assert equality with ===", function () {
+	  var expectedValue = actualValue;
+	  var actualValue = expectedValue;
+
   // toBe() will always use === to compare.
 	  expect(actualValue).toBe(expectedValue);
-  });  
+  });
 
   //Sometimes we will ask you to fill in the values.
   it("should have filled in values", function () {
-	  expect(1 + 1).toEqual(FILL_ME_IN);
+	  expect(1 + 1).toEqual(2);
   });
 });

koans/AboutFunctions.js

@@ -1,29 +1,29 @@
 describe("About Functions", function() {
 
   it("should declare functions", function() {
-    
+
     function add(a, b) {
       return a + b;
     }
-    
-    expect(add(1, 2)).toBe(FILL_ME_IN);
+
+    expect(add(1, 2)).toBe(3);
   });
 
   it("should know internal variables override outer variables", function () {
     var message = "Outer";
-    
+
     function getMessage() {
       return message;
     }
-    
+
     function overrideMessage() {
       var message = "Inner";
       return message;
     }
-    
-    expect(getMessage()).toBe(FILL_ME_IN);
-    expect(overrideMessage()).toBe(FILL_ME_IN);
-    expect(message).toBe(FILL_ME_IN);
+
+    expect(getMessage()).toBe("Outer");
+    expect(overrideMessage()).toBe("Inner");
+    expect(message).toBe("Outer");
   });
 
   it("should have lexical scoping", function () {
@@ -35,74 +35,77 @@ describe("About Functions", function() {
       }
       return childfunction();
     }
-    expect(parentfunction()).toBe(FILL_ME_IN);
+    expect(parentfunction()).toBe("local");
   });
 
   it("should use lexical scoping to synthesise functions", function () {
-    
+
     function makeIncreaseByFunction(increaseByAmount) {
       return function (numberToIncrease) {
         return numberToIncrease + increaseByAmount;
       };
     }
-    
+
     var increaseBy3 = makeIncreaseByFunction(3);
     var increaseBy5 = makeIncreaseByFunction(5);
-    
-    expect(increaseBy3(10) + increaseBy5(10)).toBe(FILL_ME_IN);
+
+    expect(increaseBy3(10) + increaseBy5(10)).toBe(28);
   });
 
   it("should allow extra function arguments", function () {
-    
+
     function returnFirstArg(firstArg) {
       return firstArg;
     }
-    
-    expect(returnFirstArg("first", "second", "third")).toBe(FILL_ME_IN);
-    
+
+    expect(returnFirstArg("first", "second", "third")).toBe("first");
+
     function returnSecondArg(firstArg, secondArg) {
       return secondArg;
     }
-    
-    expect(returnSecondArg("only give first arg")).toBe(FILL_ME_IN);
-    
+
+    expect(returnSecondArg("only give first arg")).toBe(undefined);
+
     function returnAllArgs() {
       var argsArray = [];
       for (var i = 0; i < arguments.length; i += 1) {
         argsArray.push(arguments[i]);
       }
       return argsArray.join(",");
     }
-    
-    expect(returnAllArgs("first", "second", "third")).toBe(FILL_ME_IN);
+
+    expect(returnAllArgs("first", "second", "third")).toBe('first,second,third');
   });
 
   it("should pass functions as values", function () {
 
     var appendRules = function (name) {
       return name + " rules!";
     };
-    
+
     var appendDoubleRules = function (name) {
       return name + " totally rules!";
     };
-    
+
     var praiseSinger = { givePraise: appendRules };
-    expect(praiseSinger.givePraise("John")).toBe(FILL_ME_IN);
-    
+    expect(praiseSinger.givePraise("John")).toBe("John rules!");
+
     praiseSinger.givePraise = appendDoubleRules;
-    expect(praiseSinger.givePraise("Mary")).toBe(FILL_ME_IN);
-      
+    expect(praiseSinger.givePraise("Mary")).toBe("Mary totally rules!");
+
   });
 
   it("should use function body as a string", function () {
     var add = new Function("a", "b", "return a + b;");
-    expect(add(1, 2)).toBe(FILL_ME_IN);
-     
+    expect(add(1, 2)).toBe(3);
+
     var multiply = function (a, b) {
       //An internal comment
       return a * b;
     };
-    expect(multiply.toString()).toBe(FILL_ME_IN);
-  });    
+    expect(multiply.toString()).toBe('function (a, b) {
+      //An internal comment
+      return a * b;
+    }'
+  });
 });