diff --git a/koans/AboutArrays.js b/koans/AboutArrays.js index 6fe4313cc..da2ce7cb0 100644 --- a/koans/AboutArrays.js +++ b/koans/AboutArrays.js @@ -3,16 +3,16 @@ describe("About Arrays", function() { //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'); // why isnt this just Object w/o quotes? + 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 () { @@ -23,36 +23,36 @@ describe("About Arrays", function() { 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); + 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([]); // 0 means last element in sequence, jelly is last, don't include + expect(array.slice(3, 100)).toEqual(["jelly"]); + expect(array.slice(5, 1)).toEqual([]); // interesting }); 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"); // shouldn't this be "five"?? 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]); }); }); diff --git a/koans/AboutExpects.js b/koans/AboutExpects.js index 52148b243..774e7d2a8 100644 --- a/koans/AboutExpects.js +++ b/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; - - 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; - + // To understand reality, we must compare our expectations against reality. + it("should expect equality", function () { + var expectedValue = 2; + var actualValue = 1 + 1; + + expect(actualValue === expectedValue).toBeTruthy(); + }); + + // Some ways of asserting equality are better than others. + it("should assert equality a better way", function () { + var expectedValue = 2; + var actualValue = 1 + 1; + // toEqual() compares using common sense equality. - expect(actualValue).toEqual(expectedValue); + 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(); - + // Sometimes you need to be really exact about what you "type." + it("should assert equality with ===", function () { + var expectedValue = '2'; + var actualValue = (1 + 1).toString(); + // toBe() will always use === to compare. - expect(actualValue).toBe(expectedValue); - }); + expect(actualValue).toBe(expectedValue); + }); - //Sometimes we will ask you to fill in the values. + // 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); }); }); diff --git a/koans/AboutFunctions.js b/koans/AboutFunctions.js index 77b379a3a..f98b774ad 100644 --- a/koans/AboutFunctions.js +++ b/koans/AboutFunctions.js @@ -1,71 +1,74 @@ 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(message); + expect(overrideMessage()).toBe("Inner"); + expect(message).toBe("Outer"); }); it("should have lexical scoping", function () { var variable = "top-level"; function parentfunction() { - var variable = "local"; + var variable = "local"; function childfunction() { - return variable; + return variable; } 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; + + function makeMysteryFunction(makerValue) + { + var newFunction = function doMysteriousThing(param) + { + return makerValue + param; }; + return newFunction; } - - var increaseBy3 = makeIncreaseByFunction(3); - var increaseBy5 = makeIncreaseByFunction(5); - - expect(increaseBy3(10) + increaseBy5(10)).toBe(FILL_ME_IN); + + var mysteryFunction3 = makeMysteryFunction(10); + var mysteryFunction5 = makeMysteryFunction(5); + + expect(mysteryFunction3(10) + mysteryFunction5(5)).toBe(30); // CLOSURE! }); 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) { @@ -73,8 +76,8 @@ describe("About Functions", function() { } return argsArray.join(","); } - - expect(returnAllArgs("first", "second", "third")).toBe(FILL_ME_IN); + + expect(returnAllArgs("first", "second", "third")).toBe("first,second,third"); // 'arugments' is a keyword! }); it("should pass functions as values", function () { @@ -82,27 +85,16 @@ describe("About Functions", 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); - - var multiply = function (a, b) { - //An internal comment - return a * b; - }; - expect(multiply.toString()).toBe(FILL_ME_IN); - }); + }); }); diff --git a/koans/AboutHigherOrderFunctions.js b/koans/AboutHigherOrderFunctions.js index c45b24a0e..b61317f74 100644 --- a/koans/AboutHigherOrderFunctions.js +++ b/koans/AboutHigherOrderFunctions.js @@ -9,19 +9,19 @@ describe("About Higher Order Functions", function () { it("should use filter to return array items that meet a criteria", function () { var numbers = [1,2,3]; - var odd = _(numbers).filter(function (x) { return x % 2 !== 0 }); + var odd = _(numbers).filter(function (x) { return x % 2 !== 0 }); // refers to .filter from underscore.js - expect(odd).toEqual(FILL_ME_IN); - expect(odd.length).toBe(FILL_ME_IN); - expect(numbers.length).toBe(FILL_ME_IN); + expect(odd).toEqual([1,3]); + expect(odd.length).toBe(2); + expect(numbers.length).toBe(3); }); it("should use 'map' to transform each element", function () { var numbers = [1, 2, 3]; var numbersPlus1 = _(numbers).map(function(x) { return x + 1 }); - expect(numbersPlus1).toEqual(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + expect(numbersPlus1).toEqual([2,3,4]); + expect(numbers).toEqual([1,2,3]); }); it("should use 'reduce' to update the same result on each iteration", function () { @@ -34,8 +34,8 @@ describe("About Higher Order Functions", function () { /* initial */ 0 ); - expect(reduction).toBe(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + expect(reduction).toBe(6); + expect(numbers).toEqual([1,2,3]); }); it("should use 'forEach' for simple iteration", function () { @@ -47,8 +47,8 @@ describe("About Higher Order Functions", function () { _(numbers).forEach(isEven); - expect(msg).toEqual(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + expect(msg).toEqual("falsetruefalse"); + expect(numbers).toEqual([1,2,3]); }); it("should use 'all' to test whether all items pass condition", function () { @@ -57,8 +57,8 @@ describe("About Higher Order Functions", function () { var isEven = function(x) { return x % 2 === 0 }; - expect(_(onlyEven).all(isEven)).toBe(FILL_ME_IN); - expect(_(mixedBag).all(isEven)).toBe(FILL_ME_IN); + expect(_(onlyEven).all(isEven)).toBe(true); + expect(_(mixedBag).all(isEven)).toBe(false); }); it("should use 'any' to test if any items passes condition" , function () { @@ -67,18 +67,18 @@ describe("About Higher Order Functions", function () { var isEven = function(x) { return x % 2 === 0 }; - expect(_(onlyEven).any(isEven)).toBe(FILL_ME_IN); - expect(_(mixedBag).any(isEven)).toBe(FILL_ME_IN); + expect(_(onlyEven).any(isEven)).toBe(true); + expect(_(mixedBag).any(isEven)).toBe(true); }); it("should use range to generate an array", function() { - expect(_.range(3)).toEqual(FILL_ME_IN); - expect(_.range(1, 4)).toEqual(FILL_ME_IN); - expect(_.range(0, -4, -1)).toEqual(FILL_ME_IN); + expect(_.range(3)).toEqual([0,1,2]); + expect(_.range(1, 4)).toEqual([1,2,3]); + expect(_.range(0, -4, -1)).toEqual([0,-1,-2,-3]); }); it("should use flatten to make nested arrays easy to work with", function() { - expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual(FILL_ME_IN); + expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual([1,2,3,4]); }); it("should use chain() ... .value() to use multiple higher order functions", function() { @@ -88,7 +88,7 @@ describe("About Higher Order Functions", function () { .reduce(function (sum, x) { return sum + x }) .value(); - expect(result).toEqual(FILL_ME_IN); + expect(result).toEqual(6); }); }); diff --git a/koans/AboutInheritance.js b/koans/AboutInheritance.js index 1646d8310..72dbb4a17 100644 --- a/koans/AboutInheritance.js +++ b/koans/AboutInheritance.js @@ -25,20 +25,20 @@ describe("About inheritance", function() { }); it("should be able to call a method on the derived object", function() { - expect(this.swedishChef.cook()).toEqual(FILL_ME_IN); + expect(this.swedishChef.cook()).toEqual("Mmmm soup!"); // REVIEW! }); it("should be able to call a method on the base object", function() { - expect(this.swedishChef.answerNanny()).toEqual(FILL_ME_IN); + expect(this.swedishChef.answerNanny()).toEqual("Everything's cool!"); }); it("should set constructor parameters on the base object", function() { - expect(this.swedishChef.age).toEqual(FILL_ME_IN); - expect(this.swedishChef.hobby).toEqual(FILL_ME_IN); + expect(this.swedishChef.age).toEqual(2); + expect(this.swedishChef.hobby).toEqual("cooking"); }); it("should set constructor parameters on the derived object", function() { - expect(this.swedishChef.mood).toEqual(FILL_ME_IN); + expect(this.swedishChef.mood).toEqual("chillin"); }); }); @@ -71,19 +71,19 @@ describe("About Crockford's inheritance improvement", function() { }); it("should be able to call a method on the derived object", function() { - expect(this.gonzo.doTrick()).toEqual(FILL_ME_IN); + expect(this.gonzo.doTrick()).toEqual("eat a tire"); }); it("should be able to call a method on the base object", function() { - expect(this.gonzo.answerNanny()).toEqual(FILL_ME_IN); + expect(this.gonzo.answerNanny()).toEqual("Everything's cool!"); // REVIEW }); it("should set constructor parameters on the base object", function() { - expect(this.gonzo.age).toEqual(FILL_ME_IN); - expect(this.gonzo.hobby).toEqual(FILL_ME_IN); + expect(this.gonzo.age).toEqual(3); + expect(this.gonzo.hobby).toEqual("daredevil performer"); }); it("should set constructor parameters on the derived object", function() { - expect(this.gonzo.trick).toEqual(FILL_ME_IN); + expect(this.gonzo.trick).toEqual("eat a tire"); }); }); diff --git a/koans/AboutMutability.js b/koans/AboutMutability.js index 1e4511758..e8b5a5307 100644 --- a/koans/AboutMutability.js +++ b/koans/AboutMutability.js @@ -3,8 +3,8 @@ describe("About Mutability", function() { it("should expect object properties to be public and mutable", function () { var aPerson = {firstname: "John", lastname: "Smith" }; aPerson.firstname = "Alan"; - - expect(aPerson.firstname).toBe(FILL_ME_IN); + + expect(aPerson.firstname).toBe("Alan"); }); it("should understand that constructed properties are public and mutable", function () { @@ -15,8 +15,8 @@ describe("About Mutability", function() { } var aPerson = new Person ("John", "Smith"); aPerson.firstname = "Alan"; - - expect(aPerson.firstname).toBe(FILL_ME_IN); + + expect(aPerson.firstname).toBe("Alan"); }); it("should expect prototype properties to be public and mutable", function () { @@ -28,22 +28,22 @@ describe("About Mutability", function() { Person.prototype.getFullName = function () { return this.firstname + " " + this.lastname; }; - + var aPerson = new Person ("John", "Smith"); - expect(aPerson.getFullName()).toBe(FILL_ME_IN); - + expect(aPerson.getFullName()).toBe("John Smith"); + aPerson.getFullName = function () { return this.lastname + ", " + this.firstname; }; - - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + + expect(aPerson.getFullName()).toBe("Smith, John"); }); it("should know that variables inside a constructor and constructor args are private", function () { function Person(firstname, lastname) { var fullName = firstname + " " + lastname; - + this.getFirstName = function () { return firstname; }; this.getLastName = function () { return lastname; }; this.getFullName = function () { return fullName; }; @@ -53,16 +53,16 @@ describe("About Mutability", function() { aPerson.firstname = "Penny"; aPerson.lastname = "Andrews"; aPerson.fullName = "Penny Andrews"; - - expect(aPerson.getFirstName()).toBe(FILL_ME_IN); - expect(aPerson.getLastName()).toBe(FILL_ME_IN); - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + + expect(aPerson.getFirstName()).toBe("John"); + expect(aPerson.getLastName()).toBe("Smith"); + expect(aPerson.getFullName()).toBe("John Smith"); aPerson.getFullName = function () { return aPerson.lastname + ", " + aPerson.firstname; }; - - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + + expect(aPerson.getFullName()).toBe("Andrews, Penny"); }); }); diff --git a/koans/AboutObjects.js b/koans/AboutObjects.js index 374944e80..819f49582 100644 --- a/koans/AboutObjects.js +++ b/koans/AboutObjects.js @@ -1,58 +1,58 @@ describe("About Objects", function () { describe("Properties", function () { - var meglomaniac; + var megalomaniac; beforeEach(function () { - meglomaniac = { mastermind: "Joker", henchwoman: "Harley" }; + megalomaniac = { mastermind: "Joker", henchwoman: "Harley" }; }); it("should confirm objects are collections of properties", function () { - expect(meglomaniac.mastermind).toBe(FILL_ME_IN); - }); + expect(megalomaniac.mastermind).toBe("Joker"); + }); it("should confirm that properties are case sensitive", function () { - expect(meglomaniac.henchwoman).toBe(FILL_ME_IN); - expect(meglomaniac.henchWoman).toBe(FILL_ME_IN); + expect(megalomaniac.henchwoman).toBe("Harley"); + expect(megalomaniac.henchWoman).toBe(undefined); // tricky }); }); - + it("should know properties that are functions act like methods", function () { - var meglomaniac = { - mastermind : "Brain", + var megalomaniac = { + mastermind : "Brain", henchman: "Pinky", battleCry: function (noOfBrains) { return "They are " + this.henchman + " and the" + Array(noOfBrains + 1).join(" " + this.mastermind); } }; - - var battleCry = meglomaniac.battleCry(4); - expect(FILL_ME_IN).toMatch(battleCry); + + var battleCry = megalomaniac.battleCry(4); + expect("They are Pinky and the Brain Brain Brain Brain").toMatch(battleCry); }); it("should confirm that when a function is attached to an object, 'this' refers to the object", function () { - var currentDate = new Date() + var currentDate = new Date(); var currentYear = (currentDate.getFullYear()); - var meglomaniac = { - mastermind: "James Wood", + var megalomaniac = { + mastermind: "James Wood", henchman: "Adam West", birthYear: 1970, calculateAge: function () { - return currentYear - this.birthYear; + return currentYear - this.birthYear; } }; - - expect(currentYear).toBe(FILL_ME_IN); - expect(meglomaniac.calculateAge()).toBe(FILL_ME_IN); + + expect(currentYear).toBe(2015); + expect(megalomaniac.calculateAge()).toBe(45); }); describe("'in' keyword", function () { - var meglomaniac; + var megalomaniac; beforeEach(function () { - meglomaniac = { - mastermind: "The Monarch", + megalomaniac = { + mastermind: "The Monarch", henchwoman: "Dr Girlfriend", theBomb: true }; @@ -60,50 +60,50 @@ describe("About Objects", function () { it("should have the bomb", function () { - var hasBomb = "theBomb" in meglomaniac; - - expect(hasBomb).toBe(FILL_ME_IN); + var hasBomb = "theBomb" in megalomaniac; + + expect(hasBomb).toBe(true); }); it("should not have the detonator however", function () { - var hasDetonator = "theDetonator" in meglomaniac; - - expect(hasDetonator).toBe(FILL_ME_IN); - }); + var hasDetonator = "theDetonator" in megalomaniac; + + expect(hasDetonator).toBe(false); // not 'undefined' + }); }); it("should know that properties can be added and deleted", function () { - var meglomaniac = { mastermind : "Agent Smith", henchman: "Agent Smith" }; + var megalomaniac = { mastermind : "Agent Smith", henchman: "Agent Smith" }; + + expect("secretary" in megalomaniac).toBe(false); // TRICKY! false bc property does not exist! - expect("secretary" in meglomaniac).toBe(FILL_ME_IN); + megalomaniac.secretary = "Agent Smith"; + expect("secretary" in megalomaniac).toBe(true); // .toBe is TRUE or FALSE, either throws an error or not! - meglomaniac.secretary = "Agent Smith"; - expect("secretary" in meglomaniac).toBe(FILL_ME_IN); - - delete meglomaniac.henchman; - expect("henchman" in meglomaniac).toBe(FILL_ME_IN); + delete megalomaniac.henchman; + expect("henchman" in megalomaniac).toBe(false); }); it("should use prototype to add to all objects", function () { - function Circle(radius) - { - this.radius = radius; - } - - var simpleCircle = new Circle(10); - var colouredCircle = new Circle(5); - colouredCircle.colour = "red"; - - expect(simpleCircle.colour).toBe(FILL_ME_IN); - expect(colouredCircle.colour).toBe(FILL_ME_IN); - - Circle.prototype.describe = function () { - return "This circle has a radius of: " + this.radius; - }; - - expect(simpleCircle.describe()).toBe(FILL_ME_IN); - expect(colouredCircle.describe()).toBe(FILL_ME_IN); + function Circle(radius) + { + this.radius = radius; + } + + var simpleCircle = new Circle(10); + var colouredCircle = new Circle(5); + colouredCircle.colour = "red"; + + expect(simpleCircle.colour).toBe(undefined); // TRICKY! undefined bc its accessing a nonexistent property! + expect(colouredCircle.colour).toBe("red"); + + Circle.prototype.describe = function () { + return "This circle has a radius of: " + this.radius; + }; + + expect(simpleCircle.describe()).toBe("This circle has a radius of: 10"); + expect(colouredCircle.describe()).toBe("This circle has a radius of: 5"); }); });