diff --git a/koans/src/beginner/AboutArithmeticOperators.java b/koans/src/beginner/AboutArithmeticOperators.java index 422647f4..a55f5110 100644 --- a/koans/src/beginner/AboutArithmeticOperators.java +++ b/koans/src/beginner/AboutArithmeticOperators.java @@ -9,49 +9,49 @@ public class AboutArithmeticOperators { @Koan public void simpleOperations() { - assertEquals(1, __); - assertEquals(1 + 1, __); - assertEquals(2 + 3 * 4, __); - assertEquals((2 + 3) * 4, __); - assertEquals(2 * 3 + 4, __); - assertEquals(2 - 3 + 4, __); - assertEquals(2 + 4 / 2, __); - assertEquals((2 + 4) / 2, __); + assertEquals(1, 1); + assertEquals(1 + 1, 2); + assertEquals(2 + 3 * 4, 14); + assertEquals((2 + 3) * 4, 20); + assertEquals(2 * 3 + 4, 10); + assertEquals(2 - 3 + 4, 3); + assertEquals(2 + 4 / 2, 4); + assertEquals((2 + 4) / 2, 3); } @Koan public void notSoSimpleOperations() { - assertEquals(1 / 2, __); - assertEquals(3 / 2, __); - assertEquals(1 % 2, __); - assertEquals(3 % 2, __); + assertEquals(1 / 2, 0); + assertEquals(3 / 2, 1); + assertEquals(1 % 2, 1); + assertEquals(3 % 2, 1); } @Koan public void minusMinusVariableMinusMinus() { int i = 1; - assertEquals(--i, __); - assertEquals(i, __); - assertEquals(i--, __); - assertEquals(i, __); + assertEquals(--i, 0); + assertEquals(i, 0); + assertEquals(i--, 0); + assertEquals(i, -1); } @Koan public void plusPlusVariablePlusPlus() { int i = 1; - assertEquals(++i, __); - assertEquals(i, __); - assertEquals(i++, __); - assertEquals(i, __); + assertEquals(++i, 2); + assertEquals(i, 2); + assertEquals(i++, 2); + assertEquals(i, 3); } @Koan public void timesAndDivInPlace() { int i = 1; i *= 2; - assertEquals(i, __); + assertEquals(i, 2); i /= 2; - assertEquals(i, __); + assertEquals(i, 1); } } diff --git a/koans/src/beginner/AboutArrays.java b/koans/src/beginner/AboutArrays.java index 0596e5da..501887bc 100755 --- a/koans/src/beginner/AboutArrays.java +++ b/koans/src/beginner/AboutArrays.java @@ -14,20 +14,20 @@ public void arraysDoNotConsiderElementsWhenEvaluatingEquality() { // arrays utilize default object equality (A == {1} B == {1}, though A // and B contain the same thing, the container is not the same // referenced array instance... - assertEquals(new int[]{1}.equals(new int[]{1}), __); + assertEquals(new int[]{1}.equals(new int[]{1}), false); } @Koan public void cloneEqualityIsNotRespected() { //! int[] original = new int[]{1}; - assertEquals(original.equals(original.clone()), __); + assertEquals(original.equals(original.clone()), false); } @Koan public void anArraysHashCodeMethodDoesNotConsiderElements() { int[] array0 = new int[]{0}; int[] array1 = new int[]{0}; - assertEquals(Integer.valueOf(array0.hashCode()).equals(array1.hashCode()), __); // not equal! + assertEquals(Integer.valueOf(array0.hashCode()).equals(array1.hashCode()), false); // not equal! // TODO: ponder the consequences when arrays are used in Hash Collection implementations. } @@ -35,7 +35,7 @@ public void anArraysHashCodeMethodDoesNotConsiderElements() { public void arraysHelperClassEqualsMethodConsidersElementsWhenDeterminingEquality() { int[] array0 = new int[]{0}; int[] array1 = new int[]{0}; - assertEquals(Arrays.equals(array0, array1), __); // whew - what most people assume + assertEquals(Arrays.equals(array0, array1), true); // whew - what most people assume // about equals in regard to arrays! (logical equality) } @@ -44,33 +44,33 @@ public void arraysHelperClassHashCodeMethodConsidersElementsWhenDeterminingHashC int[] array0 = new int[]{0}; int[] array1 = new int[]{0}; // whew - what most people assume about hashCode in regard to arrays! - assertEquals(Integer.valueOf(Arrays.hashCode(array0)).equals(Arrays.hashCode(array1)), __); + assertEquals(Integer.valueOf(Arrays.hashCode(array0)).equals(Arrays.hashCode(array1)), true); } @Koan public void arraysAreMutable() { final boolean[] oneBoolean = new boolean[]{false}; oneBoolean[0] = true; - assertEquals(oneBoolean[0], __); + assertEquals(oneBoolean[0], true); } @Koan public void arraysAreIndexedAtZero() { int[] integers = new int[]{1, 2}; - assertEquals(integers[0], __); - assertEquals(integers[1], __); + assertEquals(integers[0], 1); + assertEquals(integers[1], 2); } @Koan public void arrayIndexOutOfBounds() { int[] array = new int[]{1}; @SuppressWarnings("unused") - int meh = array[1]; // remember 0 based indexes, 1 is the 2nd element (which doesn't exist) + int meh = array[0]; // remember 0 based indexes, 1 is the 2nd element (which doesn't exist) } @Koan public void arrayLengthCanBeChecked() { - assertEquals(new int[1].length, __); + assertEquals(new int[1].length, 1); } } diff --git a/koans/src/beginner/AboutAssertions.java b/koans/src/beginner/AboutAssertions.java index 818662e9..471b424d 100755 --- a/koans/src/beginner/AboutAssertions.java +++ b/koans/src/beginner/AboutAssertions.java @@ -10,46 +10,46 @@ public class AboutAssertions { @Koan public void assertBooleanTrue() { // there are two possibilities, true or false, what would it be here? - assertTrue(__); + assertTrue(true); } @Koan public void assertBooleanFalse() { - assertFalse(__); + assertFalse(false); } @Koan public void assertNullObject() { // reference to the object can be null, a magic keyword, null, which means // that there is nothing there - assertNull(__); + assertNull(null); } @Koan public void assertNullObjectReference() { - Object someObject = __; + Object someObject = null; assertNull(someObject); } @Koan public void assertNotNullObject() { // but what when there should not be a null value? - assertNotNull(null); + assertNotNull(true); } @Koan public void assertEqualsUsingExpression() { - assertTrue("Hello World!".equals(__)); + assertTrue("Hello World!".equals("Hello World!")); } @Koan public void assertEqualsWithAFewExpressions() { - assertEquals("Hello World!", __); - assertEquals(1, __); - assertEquals(2 + 2, __); - assertEquals(2 * 3, __); - assertEquals(3 - 8, __); - assertEquals(10 / 2, __); + assertEquals("Hello World!", "Hello World!"); + assertEquals(1, 1); + assertEquals(2 + 2, 4); + assertEquals(2 * 3, 6); + assertEquals(3 - 8, -5); + assertEquals(10 / 2, 5); } @Koan @@ -57,7 +57,7 @@ public void assertEqualsWithDescriptiveMessage() { // Generally, when using an assertXXX methods, expectation is on the // left and it is best practice to use a String for the first arg // indication what has failed - assertEquals("The answer to 'life the universe and everything' should be 42", 42, __); + assertEquals("The answer to 'life the universe and everything' should be 42", 42, 42); } @Koan @@ -65,14 +65,14 @@ public void assertSameInstance() { // Just because something is equal doesn't mean that it is the same. // It's only the same if the reference is the same. Object same = new Integer(1); - Object sameReference = __; + Object sameReference = same; assertSame(same, sameReference); } @Koan public void assertNotSameInstance() { Integer same = new Integer(1); - Integer sameReference = same; + Integer sameReference = 1; assertNotSame(same, sameReference); } } diff --git a/koans/src/beginner/AboutBitwiseOperators.java b/koans/src/beginner/AboutBitwiseOperators.java index b2d17451..423350ad 100644 --- a/koans/src/beginner/AboutBitwiseOperators.java +++ b/koans/src/beginner/AboutBitwiseOperators.java @@ -11,14 +11,14 @@ public class AboutBitwiseOperators { public void fullAnd() { int i = 1; if (true & (++i < 8)) i = i + 1; - assertEquals(i, __); + assertEquals(i, 3); } @Koan public void shortCircuitAnd() { int i = 1; if (true && (i < -28)) i = i + 1; - assertEquals(i, __); + assertEquals(i, 1); } @Koan @@ -26,7 +26,7 @@ public void aboutXOR() { int i = 1; int a = 6; if ((a < 9) ^ false) i = i + 1; - assertEquals(i, __); + assertEquals(i, 2); } @Koan @@ -34,8 +34,8 @@ public void dontMistakeEqualsForEqualsEquals() { int i = 1; boolean a = false; if (a = true) i++; - assertEquals(a, __); - assertEquals(i, __); + assertEquals(a, true); + assertEquals(i, 2); // How could you write the condition 'with a twist' to avoid this trap? } @@ -43,23 +43,23 @@ public void dontMistakeEqualsForEqualsEquals() { public void aboutBitShiftingRightShift() { int rightShift = 8; rightShift = rightShift >> 1; - assertEquals(rightShift, __); + assertEquals(rightShift, 4); } @Koan public void aboutBitShiftingLeftShift() { int leftShift = 0x80000000; // Is this number positive or negative? leftShift = leftShift << 1; - assertEquals(leftShift, __); + assertEquals(leftShift, 0); } @Koan public void aboutBitShiftingRightUnsigned() { int rightShiftNegativeStaysNegative = 0x80000000; rightShiftNegativeStaysNegative = rightShiftNegativeStaysNegative >> 4; - assertEquals(rightShiftNegativeStaysNegative, __); + assertEquals(rightShiftNegativeStaysNegative, -134217728); int unsignedRightShift = 0x80000000; // always fills with 0 unsignedRightShift >>>= 4; // Just like += - assertEquals(unsignedRightShift, __); + assertEquals(unsignedRightShift, 134217728); } } diff --git a/koans/src/beginner/AboutCasting.java b/koans/src/beginner/AboutCasting.java index a0520b50..03584004 100644 --- a/koans/src/beginner/AboutCasting.java +++ b/koans/src/beginner/AboutCasting.java @@ -14,9 +14,9 @@ public void longPlusInt() { int a = 6; long b = 10; Object c = a + b; - assertEquals(c, __); - assertEquals(c instanceof Integer, __); - assertEquals(c instanceof Long, __); + assertEquals(c, 16l); + assertEquals(c instanceof Integer, false); + assertEquals(c instanceof Long, true); } @Koan @@ -24,7 +24,7 @@ public void forceIntTypecast() { long a = 2147483648L; // What happens if we force a long value into an int? int b = (int) a; - assertEquals(b, __); + assertEquals(b, -2147483648); } @Koan @@ -32,7 +32,7 @@ public void implicitTypecast() { int a = 1; int b = Integer.MAX_VALUE; long c = a + b; // still overflows int... which is the Integer.MIN_VALUE, the operation occurs prior to assignment to long - assertEquals(c, __); + assertEquals(c, -2147483648l); } interface Sleepable { @@ -61,10 +61,10 @@ public String complain() { public void upcastWithInheritance() { Child child = new Child(); Parent parentReference = child; // Why isn't there an explicit cast? - assertEquals(child instanceof Child, __); - assertEquals(parentReference instanceof Child, __); - assertEquals(parentReference instanceof Parent, __); - assertEquals(parentReference instanceof Grandparent, __); + assertEquals(child instanceof Child, true); + assertEquals(parentReference instanceof Child, true); + assertEquals(parentReference instanceof Parent, true); + assertEquals(parentReference instanceof Grandparent, true); } @Koan @@ -72,7 +72,7 @@ public void upcastAndPolymorphism() { Child child = new Child(); Parent parentReference = child; // If the result is unexpected, consider the difference between an instance and its reference - assertEquals(parentReference.complain(), __); + assertEquals(parentReference.complain(), "Are we there yet!!"); } @Koan @@ -80,9 +80,9 @@ public void downcastWithInheritance() { Grandparent child = new Child(); Parent parentReference = (Parent) child; // Why do we need an explicit cast here? Child childReference = (Child) parentReference; // Or here? - assertEquals(childReference instanceof Child, __); - assertEquals(childReference instanceof Parent, __); - assertEquals(childReference instanceof Grandparent, __); + assertEquals(childReference instanceof Child, true); + assertEquals(childReference instanceof Parent, true); + assertEquals(childReference instanceof Grandparent, true); } @Koan @@ -91,13 +91,13 @@ public void downcastAndPolymorphism() { Parent parent = (Child) child; // Think about the result. Did you expect that? Why? // How is that different from above? - assertEquals(parent.complain(), __); + assertEquals(parent.complain(), "Are we there yet!!"); } @Koan public void classCasting() { try { - Object o = new Object(); + Object o = new Grandparent(); ((Sleepable) o).sleep(); // would this even compile without the cast? } catch (ClassCastException x) { fail("Object does not implement Sleepable, maybe one of the people classes do?"); @@ -108,7 +108,7 @@ public void classCasting() { public void complicatedCast() { Grandparent parent = new Parent(); // How can we access the parent's ability to "complain" - if the reference is held as a superclass? - assertEquals("TPS reports don't even have a cover letter!", __); + assertEquals("TPS reports don't even have a cover letter!", ((Parent) parent).complain()); } } diff --git a/koans/src/beginner/AboutConditionals.java b/koans/src/beginner/AboutConditionals.java index f7883dfb..29b9873f 100644 --- a/koans/src/beginner/AboutConditionals.java +++ b/koans/src/beginner/AboutConditionals.java @@ -15,7 +15,7 @@ public void basicIf() { if (true) { x++; } - assertEquals(x, __); + assertEquals(x, 2); } @Koan @@ -27,7 +27,7 @@ public void basicIfElse() { } else { x--; } - assertEquals(x, __); + assertEquals(x, 0); } @Koan @@ -42,7 +42,7 @@ public void basicIfElseIfElse() { } else { x--; } - assertEquals(x, __); + assertEquals(x, 10); } @Koan @@ -61,7 +61,7 @@ public void nestedIfsWithoutCurlysAreReallyMisleading() { x--; } // Where does this else belong to!? - assertEquals(x, __); + assertEquals(x, 10); } @Koan @@ -78,7 +78,7 @@ public void basicSwitchStatement() { default: result += "Nothing"; } - assertEquals(result, __); + assertEquals(result, "Basic One"); } @Koan @@ -93,7 +93,7 @@ public void switchStatementFallThrough() { default: result += "Nothing"; } - assertEquals(result, __); + assertEquals(result, "Basic OneTwoNothing"); } @Koan @@ -108,7 +108,7 @@ public void switchStatementCrazyFallThrough() { case 2: result += "Two"; } - assertEquals(result, __); + assertEquals(result, "Basic NothingTwo"); } @Koan @@ -125,7 +125,7 @@ public void switchStatementConstants() { default: result += "Nothing"; } - assertEquals(result, __); + assertEquals(result, "Basic Nothing"); } @Koan @@ -142,7 +142,7 @@ public void switchStatementSwitchValues() { default: result += "Nothing"; } - assertEquals(result, __); + assertEquals(result, "Basic One"); } @Koan @@ -152,6 +152,6 @@ public void shortCircuit() { // Why did we use a variable here? // What happens if you replace 'a' with '6' below? if ((a < 9) || (++i < 8)) i = i + 1; - assertEquals(i, __); + assertEquals(i, 2); } } diff --git a/koans/src/beginner/AboutConstructors.java b/koans/src/beginner/AboutConstructors.java index e2cd6855..4a01fb2b 100644 --- a/koans/src/beginner/AboutConstructors.java +++ b/koans/src/beginner/AboutConstructors.java @@ -26,7 +26,7 @@ public B() { @Koan public void simpleConstructorOrder() { - assertEquals(new B().someString, __); + assertEquals(new B().someString, "axg"); } class Aa { @@ -51,7 +51,7 @@ public Bb() { @Koan public void complexConstructorOrder() { - assertEquals(new Bb().someString, __); + assertEquals(new Bb().someString, "aBoog"); } } diff --git a/koans/src/beginner/AboutEnums.java b/koans/src/beginner/AboutEnums.java index 807f5567..6ba9e74b 100644 --- a/koans/src/beginner/AboutEnums.java +++ b/koans/src/beginner/AboutEnums.java @@ -16,15 +16,15 @@ enum Colors { @Koan public void basicEnums() { Colors blue = Colors.Blue; - assertEquals(blue == Colors.Blue, __); - assertEquals(blue == Colors.Red, __); - assertEquals(blue instanceof Colors, __); + assertEquals(blue == Colors.Blue, true); + assertEquals(blue == Colors.Red, false); + assertEquals(blue instanceof Colors, true); } @Koan public void basicEnumsAccess() { Colors[] colorArray = Colors.values(); - assertEquals(colorArray[2], __); + assertEquals(colorArray[2], Colors.Green); } enum SkatSuits { @@ -42,7 +42,7 @@ public void enumsWithAttributes() { // value is private but we still can access it. Why? // Try moving the enum outside the AboutEnum class... What do you expect? // What happens? - assertEquals(SkatSuits.Clubs.value > SkatSuits.Spades.value, __); + assertEquals(SkatSuits.Clubs.value > SkatSuits.Spades.value, true); } enum OpticalMedia { @@ -61,7 +61,7 @@ int getCoolnessFactor() { @Koan public void enumsWithMethods() { - assertEquals(OpticalMedia.CD.getCoolnessFactor(), __); - assertEquals(OpticalMedia.BluRay.getCoolnessFactor(), __); + assertEquals(OpticalMedia.CD.getCoolnessFactor(), -3500); + assertEquals(OpticalMedia.BluRay.getCoolnessFactor(), 490000); } } diff --git a/koans/src/beginner/AboutEquality.java b/koans/src/beginner/AboutEquality.java index 18ac70cf..6903ce7f 100644 --- a/koans/src/beginner/AboutEquality.java +++ b/koans/src/beginner/AboutEquality.java @@ -11,22 +11,22 @@ public class AboutEquality { public void doubleEqualsTestsIfTwoObjectsAreTheSame() { Object object = new Object(); Object sameObject = object; - assertEquals(object == sameObject, __); - assertEquals(object == new Object(), __); + assertEquals(object == sameObject, true); + assertEquals(object == new Object(), false); } @Koan public void equalsMethodByDefaultTestsIfTwoObjectsAreTheSame() { Object object = new Object(); - assertEquals(object.equals(object), __); - assertEquals(object.equals(new Object()), __); + assertEquals(object.equals(object), true); + assertEquals(object.equals(new Object()), false); } @Koan public void equalsMethodCanBeChangedBySubclassesToTestsIfTwoObjectsAreEqual() { Object object = new Integer(1); - assertEquals(object.equals(object), __); - assertEquals(object.equals(new Integer(1)), __); + assertEquals(object.equals(object), true); + assertEquals(object.equals(new Integer(1)), true); // Note: This means that for the class 'Object' there is no difference between 'equal' and 'same' // but for the class 'Integer' there is difference - see below } @@ -35,18 +35,18 @@ public void equalsMethodCanBeChangedBySubclassesToTestsIfTwoObjectsAreEqual() { public void equalsMethodCanBeChangedBySubclassesToTestsIfTwoObjectsAreEqualExample() { Integer value1 = new Integer(4); Integer value2 = new Integer(2 + 2); - assertEquals(value1.equals(value2), __); - assertEquals(value1, __); + assertEquals(value1.equals(value2), true); + assertEquals(value1, value2); } @Koan public void objectsNeverEqualNull() { - assertEquals(new Object().equals(null), __); + assertEquals(new Object().equals(null), false); } @Koan public void objectsEqualThemselves() { Object obj = new Object(); - assertEquals(obj.equals(obj), __); + assertEquals(obj.equals(obj), true); } } diff --git a/koans/src/beginner/AboutExceptions.java b/koans/src/beginner/AboutExceptions.java index b54ee194..b3d74b36 100644 --- a/koans/src/beginner/AboutExceptions.java +++ b/koans/src/beginner/AboutExceptions.java @@ -22,7 +22,7 @@ public void catchCheckedExceptions() { } catch (IOException e) { s = "exception thrown"; } - assertEquals(s, __); + assertEquals(s, "exception thrown"); } @Koan @@ -36,7 +36,7 @@ public void useFinally() { } finally { s += " and finally ran as well"; } - assertEquals(s, __); + assertEquals(s, "exception thrown and finally ran as well"); } @Koan @@ -47,7 +47,7 @@ public void finallyWithoutCatch() { } finally { s += " and finally ran as well"; } - assertEquals(s, __); + assertEquals(s, "code ran normally and finally ran as well"); } private void tryCatchFinallyWithVoidReturn(StringBuilder whatHappened) { @@ -66,7 +66,7 @@ private void tryCatchFinallyWithVoidReturn(StringBuilder whatHappened) { public void finallyIsAlwaysRan() { StringBuilder whatHappened = new StringBuilder(); tryCatchFinallyWithVoidReturn(whatHappened); - assertEquals(whatHappened.toString(), __); + assertEquals(whatHappened.toString(), "did something dangerous; the catch block executed, but so did the finally!"); } @SuppressWarnings("finally") @@ -91,8 +91,8 @@ private String returnStatementsEverywhere(StringBuilder whatHappened) { public void returnInFinallyBlock() { StringBuilder whatHappened = new StringBuilder(); // Which value will be returned here? - assertEquals(returnStatementsEverywhere(whatHappened), __); - assertEquals(whatHappened.toString(), __); + assertEquals(returnStatementsEverywhere(whatHappened), "from finally"); + assertEquals(whatHappened.toString(), "try, catch, finally"); } private void doUncheckedStuff() { @@ -102,7 +102,12 @@ private void doUncheckedStuff() { @Koan public void catchUncheckedExceptions() { // What do you need to do to catch the unchecked exception? - doUncheckedStuff(); + try { + doUncheckedStuff(); + } + catch (RuntimeException e){ + + } } @SuppressWarnings("serial") @@ -127,7 +132,7 @@ public void catchOrder() { } catch (ParentException e) { s = "ParentException"; } - assertEquals(s, __); + assertEquals(s, "ChildException"); } @Koan @@ -139,7 +144,7 @@ public void failArgumentValidationWithAnIllegalArgumentException() { } catch (IllegalArgumentException ex) { s = "caught an IllegalArgumentException"; } - assertEquals(s, __); + assertEquals(s, "caught an IllegalArgumentException"); } @Koan @@ -151,7 +156,7 @@ public void passArgumentValidationWithAnIllegalArgumentException() { } catch (IllegalArgumentException ex) { s = "caught an IllegalArgumentException"; } - assertEquals(s, __); + assertEquals(s, "5"); } private int validateUsingIllegalArgumentException(String str) { diff --git a/koans/src/beginner/AboutInheritance.java b/koans/src/beginner/AboutInheritance.java index 22068058..db899400 100644 --- a/koans/src/beginner/AboutInheritance.java +++ b/koans/src/beginner/AboutInheritance.java @@ -44,12 +44,12 @@ public void methodOverloading() { Cow bob = new Cow(); Dog max = new Dog(); Puppy barney = new Puppy(); - assertEquals(bob.makeSomeNoise(), __); - assertEquals(max.makeSomeNoise(), __); - assertEquals(barney.makeSomeNoise(), __); + assertEquals(bob.makeSomeNoise(), "Moo!"); + assertEquals(max.makeSomeNoise(), "Woof!"); + assertEquals(barney.makeSomeNoise(), "Squeak!"); - assertEquals(max.canFetch(), __); - assertEquals(barney.canFetch(), __); + assertEquals(max.canFetch(), true); + assertEquals(barney.canFetch(), false); // but can Bob the Cow fetch? } @@ -58,33 +58,32 @@ public void methodOverloadingUsingPolymorphism() { Animal bob = new Cow(); Animal max = new Dog(); Animal barney = new Puppy(); - assertEquals(bob.makeSomeNoise(), __); - assertEquals(max.makeSomeNoise(), __); - assertEquals(barney.makeSomeNoise(), __); + assertEquals(bob.makeSomeNoise(), "Moo!"); + assertEquals(max.makeSomeNoise(), "Woof!"); + assertEquals(barney.makeSomeNoise(), "Squeak!"); // but can max or barney (here as an Animal) fetch? - // try to write it down here } @Koan public void inheritanceHierarchy() { Animal someAnimal = new Cow(); Animal bob = new Cow(); - assertEquals(someAnimal.makeSomeNoise().equals(bob.makeSomeNoise()), __); + assertEquals(someAnimal.makeSomeNoise().equals(bob.makeSomeNoise()), true); // cow is a Cow, but it can also be an animal - assertEquals(bob instanceof Animal, __); - assertEquals(bob instanceof Cow, __); + assertEquals(bob instanceof Animal, true); + assertEquals(bob instanceof Cow, true); // but is it a Puppy? - assertEquals(bob instanceof Puppy, __); + assertEquals(bob instanceof Puppy, false); } @Koan public void deeperInheritanceHierarchy() { Dog max = new Dog(); Puppy barney = new Puppy(); - assertEquals(max instanceof Puppy, __); - assertEquals(max instanceof Dog, __); - assertEquals(barney instanceof Puppy, __); - assertEquals(barney instanceof Dog, __); + assertEquals(max instanceof Puppy, false); + assertEquals(max instanceof Dog, true); + assertEquals(barney instanceof Puppy, true); + assertEquals(barney instanceof Dog, true); } // TODO overriding diff --git a/koans/src/beginner/AboutKoans.java b/koans/src/beginner/AboutKoans.java index 5ab0c236..fc36c266 100644 --- a/koans/src/beginner/AboutKoans.java +++ b/koans/src/beginner/AboutKoans.java @@ -8,12 +8,12 @@ public class AboutKoans { @Koan public void findAboutKoansFile() { - fail("delete this line to advance"); + } @Koan public void definitionOfKoanCompletion() { - boolean koanIsComplete = false; + boolean koanIsComplete = true; if (!koanIsComplete) { fail("what if koanIsComplete variable was true?"); } diff --git a/koans/src/beginner/AboutLoops.java b/koans/src/beginner/AboutLoops.java index 2a27e89c..a37c74ff 100644 --- a/koans/src/beginner/AboutLoops.java +++ b/koans/src/beginner/AboutLoops.java @@ -15,7 +15,7 @@ public void basicForLoop1() { for (int i = 0; i < 5; i++) { s += i + " "; } - assertEquals(s, __); + assertEquals(s, "0 1 2 3 4 "); } @Koan @@ -24,7 +24,7 @@ public void basicForLoop2() { for (int i = -5; i < 1; i++) { s += i + " "; } - assertEquals(s, __); + assertEquals(s, "-5 -4 -3 -2 -1 0 "); } @Koan @@ -33,7 +33,7 @@ public void basicForLoop3() { for (int i = 5; i > 0; i--) { s += i + " "; } - assertEquals(s, __); + assertEquals(s, "5 4 3 2 1 "); } @Koan @@ -42,7 +42,7 @@ public void basicForLoop4() { for (int i = 0; i < 11; i += 2) { s += i + " "; } - assertEquals(s, __); + assertEquals(s, "0 2 4 6 8 10 "); } @Koan @@ -51,7 +51,7 @@ public void basicForLoop5() { for (int i = 1; i <= 16; i *= 2) { s += i + " "; } - assertEquals(s, __); + assertEquals(s, "1 2 4 8 16 "); } @Koan @@ -60,7 +60,7 @@ public void basicForLoopWithTwoVariables1() { for (int i = 0, j = 10; i < 5 && j > 5; i++, j--) { s += i + " " + j + " "; } - assertEquals(s, __); + assertEquals(s, "0 10 1 9 2 8 3 7 4 6 "); } @Koan @@ -72,7 +72,7 @@ public void nestedLoops() { } s += " - "; } - assertEquals(s, __); + assertEquals(s, "(0, 0) (0, 1) (0, 2) - (1, 0) (1, 1) (1, 2) - (2, 0) (2, 1) (2, 2) - "); } @Koan @@ -82,7 +82,7 @@ public void extendedForLoop() { for (int j : is) { s += j + " "; } - assertEquals(s, __); + assertEquals(s, "1 2 3 4 "); } @Koan @@ -91,7 +91,7 @@ public void whileLoop() { while (result < 3) { result++; } - assertEquals(result, __); + assertEquals(result, 3); } @Koan @@ -100,7 +100,7 @@ public void doLoop() { do { result++; } while (false); - assertEquals(result, __); + assertEquals(result, 1); } @Koan @@ -113,7 +113,7 @@ public void extendedForLoopBreak() { } count++; } - assertEquals(count, __); + assertEquals(count, 1); } @Koan @@ -127,7 +127,7 @@ public void extendedForLoopContinue() { count++; } } - assertEquals(count, __); + assertEquals(count, 2); } @Koan @@ -145,7 +145,7 @@ public void forLoopContinueLabel() { } // What does continue with a label mean? // What gets executed? Where does the program flow continue? - assertEquals(count, __); + assertEquals(count, 8); } @Koan @@ -163,6 +163,6 @@ public void forLoopBreakLabel() { } // What does break with a label mean? // What gets executed? Where does the program flow continue? - assertEquals(count, __); + assertEquals(count, 3); } } diff --git a/koans/src/beginner/AboutMethodPreference.java b/koans/src/beginner/AboutMethodPreference.java index 52063487..9a8a3b67 100644 --- a/koans/src/beginner/AboutMethodPreference.java +++ b/koans/src/beginner/AboutMethodPreference.java @@ -27,30 +27,30 @@ public String doStuff(int... i) { @Koan public void methodPreferenceInt() { - assertEquals(new A().doStuff(1), __); + assertEquals(new A().doStuff(1), "int"); } @Koan public void methodPreferenceInteger() { - assertEquals(new A().doStuff(Integer.valueOf(1)), __); + assertEquals(new A().doStuff(Integer.valueOf(1)), "Integer"); } @Koan public void methodPreferenceLong() { long l = 1; - assertEquals(new A().doStuff(l), __); + assertEquals(new A().doStuff(l), "Object"); } @Koan public void methodPreferenceBoxedLong() { Long l = Long.valueOf(1); - assertEquals(new A().doStuff(l), __); + assertEquals(new A().doStuff(l), "Object"); } @Koan public void methodPreferenceDouble() { Double l = Double.valueOf(1); - assertEquals(new A().doStuff(l), __); + assertEquals(new A().doStuff(l), "Object"); } @Koan @@ -58,6 +58,6 @@ public void methodPreferenceMore() { // What happens if you change 'Integer' to 'Double' // Does this explain 'methodPreferenceDouble'? // Think about why this happens? - assertEquals(new A().doStuff(1, Integer.valueOf(2)), __); + assertEquals(new A().doStuff(1, Integer.valueOf(2)), "int vararg"); } } diff --git a/koans/src/beginner/AboutObjects.java b/koans/src/beginner/AboutObjects.java index df66e647..58d2b321 100755 --- a/koans/src/beginner/AboutObjects.java +++ b/koans/src/beginner/AboutObjects.java @@ -13,7 +13,7 @@ public class AboutObjects { @Koan public void newObjectInstancesCanBeCreatedDirectly() { - assertEquals(new Object() instanceof Object, __); + assertEquals(new Object() instanceof Object,true); } @Koan @@ -22,15 +22,15 @@ class Foo { } Class[] ancestors = getAncestors(new Foo()); - assertEquals(ancestors[0], __); - assertEquals(ancestors[1], __); + assertEquals(ancestors[0], Foo.class); + assertEquals(ancestors[1], Object.class); } @Koan public void objectToString() { Object object = new Object(); String expectedToString = MessageFormat.format("{0}@{1}", Object.class.getName(), Integer.toHexString(object.hashCode())); - assertEquals(expectedToString, __); // hint: object.toString() + assertEquals(expectedToString, object.toString()); // hint: object.toString() } @Koan @@ -42,7 +42,7 @@ public String toString() { return string; } }; - assertEquals(string + object, __); + assertEquals(string + object, "haha"); } @Koan @@ -50,7 +50,7 @@ public void toStringIsTestedForNullWhenInvokedImplicitly() { String string = "string"; Integer i = new Integer(128); Short s = new Short((short) 15); - assertEquals(string + " " + i + " " + s, __); + assertEquals(string + " " + i + " " + s, "string 128 15"); } private Class[] getAncestors(Object object) { diff --git a/koans/src/beginner/AboutPrimitives.java b/koans/src/beginner/AboutPrimitives.java index f8a240b5..a6cddf33 100644 --- a/koans/src/beginner/AboutPrimitives.java +++ b/koans/src/beginner/AboutPrimitives.java @@ -9,13 +9,13 @@ public class AboutPrimitives { @Koan public void wholeNumbersAreOfTypeInt() { - assertEquals(getType(1), __); // hint: int.class + assertEquals(getType(1), int.class); // hint: int.class } @Koan public void primitivesOfTypeIntHaveAnObjectTypeInteger() { Object number = 1; - assertEquals(getType(number), __); + assertEquals(getType(number), Integer.class); // Primitives can be automatically changed into their object type via a process called auto-boxing // We will explore this in more detail in intermediate.AboutAutoboxing @@ -23,173 +23,173 @@ public void primitivesOfTypeIntHaveAnObjectTypeInteger() { @Koan public void integersHaveAFairlyLargeRange() { - assertEquals(Integer.MIN_VALUE, __); - assertEquals(Integer.MAX_VALUE, __); + assertEquals(Integer.MIN_VALUE, -2147483648); + assertEquals(Integer.MAX_VALUE, 2147483647); } @Koan public void integerSize() { - assertEquals(Integer.SIZE, __); // This is the amount of bits used to store an int + assertEquals(Integer.SIZE,32); // This is the amount of bits used to store an int } @Koan public void wholeNumbersCanAlsoBeOfTypeLong() { - assertEquals(getType(1L), __); + assertEquals(getType(1L), long.class); } @Koan public void primitivesOfTypeLongHaveAnObjectTypeLong() { Object number = 1L; - assertEquals(getType(number), __); + assertEquals(getType(number), Long.class); } @Koan public void longsHaveALargerRangeThanInts() { - assertEquals(Long.MIN_VALUE, __); - assertEquals(Long.MAX_VALUE, __); + assertEquals(Long.MIN_VALUE, -9223372036854775808L); + assertEquals(Long.MAX_VALUE, 9223372036854775807L); } @Koan public void longSize() { - assertEquals(Long.SIZE, __); + assertEquals(Long.SIZE, 64); } @Koan public void wholeNumbersCanAlsoBeOfTypeShort() { - assertEquals(getType((short) 1), __); // The '(short)' is called an explicit cast - to type 'short' + assertEquals(getType((short) 1), short.class); // The '(short)' is called an explicit cast - to type 'short' } @Koan public void primitivesOfTypeShortHaveAnObjectTypeShort() { Object number = (short) 1; - assertEquals(getType(number), __); + assertEquals(getType(number), Short.class); } @Koan public void shortsHaveASmallerRangeThanInts() { - assertEquals(Short.MIN_VALUE, __); // hint: You'll need an explicit cast - assertEquals(Short.MAX_VALUE, __); + assertEquals(Short.MIN_VALUE, (short)-32768); // hint: You'll need an explicit cast + assertEquals(Short.MAX_VALUE, (short)32767); } @Koan public void shortSize() { - assertEquals(Short.SIZE, __); + assertEquals(Short.SIZE, 16); } @Koan public void wholeNumbersCanAlsoBeOfTypeByte() { - assertEquals(getType((byte) 1), __); + assertEquals(getType((byte) 1), byte.class); } @Koan public void primitivesOfTypeByteHaveAnObjectTypeByte() { Object number = (byte) 1; - assertEquals(getType(number), __); + assertEquals(getType(number), Byte.class); } @Koan public void bytesHaveASmallerRangeThanShorts() { - assertEquals(Byte.MIN_VALUE, __); - assertEquals(Byte.MAX_VALUE, __); + assertEquals(Byte.MIN_VALUE, (byte)-128); + assertEquals(Byte.MAX_VALUE, (byte)127); // Why would you use short or byte considering that you need to do explicit casts? } @Koan public void byteSize() { - assertEquals(Byte.SIZE, __); + assertEquals(Byte.SIZE, 8); } @Koan public void wholeNumbersCanAlsoBeOfTypeChar() { - assertEquals(getType((char) 1), __); + assertEquals(getType((char) 1), char.class); } @Koan public void singleCharactersAreOfTypeChar() { - assertEquals(getType('a'), __); + assertEquals(getType('a'), char.class); } @Koan public void primitivesOfTypeCharHaveAnObjectTypeCharacter() { Object number = (char) 1; - assertEquals(getType(number), __); + assertEquals(getType(number), Character.class); } @Koan public void charsCanOnlyBePositive() { - assertEquals((int) Character.MIN_VALUE, __); - assertEquals((int) Character.MAX_VALUE, __); + assertEquals((int) Character.MIN_VALUE, 0); + assertEquals((int) Character.MAX_VALUE, 65535); // Why did we cast MIN_VALUE and MAX_VALUE to int? Try it without the cast. } @Koan public void charSize() { - assertEquals(Character.SIZE, __); + assertEquals(Character.SIZE, 16); } @Koan public void decimalNumbersAreOfTypeDouble() { - assertEquals(getType(1.0), __); + assertEquals(getType(1.0), double.class); } @Koan public void primitivesOfTypeDoubleCanBeDeclaredWithoutTheDecimalPoint() { - assertEquals(getType(1d), __); + assertEquals(getType(1d), double.class); } @Koan public void primitivesOfTypeDoubleCanBeDeclaredWithExponents() { - assertEquals(getType(1e3), __); - assertEquals(1.0e3, __); - assertEquals(1E3, __); + assertEquals(getType(1e3), double.class); + assertEquals(1.0e3, 1000.0); + assertEquals(1E3, 1000.0); } @Koan public void primitivesOfTypeDoubleHaveAnObjectTypeDouble() { Object number = 1.0; - assertEquals(getType(number), __); + assertEquals(getType(number), Double.class); } @Koan public void doublesHaveALargeRange() { - assertEquals(Double.MIN_VALUE, __); - assertEquals(Double.MAX_VALUE, __); + assertEquals(Double.MIN_VALUE, 4.9E-324); + assertEquals(Double.MAX_VALUE, 1.7976931348623157E308); } @Koan public void doubleSize() { - assertEquals(Double.SIZE, __); + assertEquals(Double.SIZE, 64); } @Koan public void decimalNumbersCanAlsoBeOfTypeFloat() { - assertEquals(getType(1f), __); + assertEquals(getType(1f), float.class); } @Koan public void primitivesOfTypeFloatCanBeDeclaredWithExponents() { - assertEquals(getType(1e3f), __); - assertEquals(1.0e3f, __); - assertEquals(1E3f, __); + assertEquals(getType(1e3f), float.class); + assertEquals(1.0e3f, 1000.0f); + assertEquals(1E3f, 1000.0f); } @Koan public void primitivesOfTypeFloatHaveAnObjectTypeFloat() { Object number = 1f; - assertEquals(getType(number), __); + assertEquals(getType(number), Float.class); } @Koan public void floatsHaveASmallerRangeThanDoubles() { - assertEquals(Float.MIN_VALUE, __); - assertEquals(Float.MAX_VALUE, __); + assertEquals(Float.MIN_VALUE, 1.4E-45f); + assertEquals(Float.MAX_VALUE, 3.4028235E38f); } @Koan public void floatSize() { - assertEquals(Float.SIZE, __); + assertEquals(Float.SIZE, 32); } private Class getType(int value) { diff --git a/koans/src/beginner/AboutStrings.java b/koans/src/beginner/AboutStrings.java index 600cfa0a..a8d24770 100644 --- a/koans/src/beginner/AboutStrings.java +++ b/koans/src/beginner/AboutStrings.java @@ -12,7 +12,7 @@ public class AboutStrings { @Koan public void implicitStrings() { - assertEquals("just a plain ole string".getClass(), __); + assertEquals("just a plain ole string".getClass(), "hola".getClass()); } @Koan @@ -21,47 +21,47 @@ public void newString() { // practice - generally it is redundant, and done repetitively can be slow String string = new String(); String empty = ""; - assertEquals(string.equals(empty), __); + assertEquals(string.equals(empty), true); } @Koan public void newStringIsRedundant() { String stringInstance = "zero"; String stringReference = new String(stringInstance); - assertEquals(stringInstance.equals(stringReference), __); + assertEquals(stringInstance.equals(stringReference), true); } @Koan public void newStringIsNotIdentical() { String stringInstance = "zero"; String stringReference = new String(stringInstance); - assertEquals(stringInstance == stringReference, __); + assertEquals(stringInstance == stringReference, false); } @Koan public void stringIsEmpty() { - assertEquals("".isEmpty(), __); - assertEquals("one".isEmpty(), __); - assertEquals(new String().isEmpty(), __); - assertEquals(new String("").isEmpty(), __); - assertEquals(new String("one").isEmpty(), __); + assertEquals("".isEmpty(), true); + assertEquals("one".isEmpty(), false); + assertEquals(new String().isEmpty(), true); + assertEquals(new String("").isEmpty(), true); + assertEquals(new String("one").isEmpty(), false); } @Koan public void stringLength() { - assertEquals("".length(), __); - assertEquals("one".length(), __); - assertEquals("the number is one".length(), __); + assertEquals("".length(), 0); + assertEquals("one".length(), 3); + assertEquals("the number is one".length(), 17); } @Koan public void stringTrim() { - assertEquals("".trim(), __); + assertEquals("".trim(), ""); assertEquals("one".trim(), "one"); - assertEquals(" one more time".trim(), __); - assertEquals(" one more time ".trim(), __); - assertEquals(" and again\t".trim(), __); - assertEquals("\t\t\twhat about now?\t".trim(), __); + assertEquals(" one more time".trim(), "one more time"); + assertEquals(" one more time ".trim(), "one more time"); + assertEquals(" and again\t".trim(), "and again"); + assertEquals("\t\t\twhat about now?\t".trim(), "what about now?"); } @Koan @@ -69,93 +69,93 @@ public void stringConcatenation() { String one = "one"; String space = " "; String two = "two"; - assertEquals(one + space + two, __); - assertEquals(space + one + two, __); - assertEquals(two + space + one, __); + assertEquals(one + space + two, "one two"); + assertEquals(space + one + two, " onetwo"); + assertEquals(two + space + one, "two one"); } @Koan public void stringUpperCase() { String str = "I am a number one!"; - assertEquals(str.toUpperCase(), __); + assertEquals(str.toUpperCase(), "I AM A NUMBER ONE!"); } @Koan public void stringLowerCase() { String str = "I AM a number ONE!"; - assertEquals(str.toLowerCase(), __); + assertEquals(str.toLowerCase(), "i am a number one!"); } @Koan public void stringCompare() { String str = "I AM a number ONE!"; - assertEquals(str.compareTo("I AM a number ONE!") == 0, __); - assertEquals(str.compareTo("I am a number one!") == 0, __); - assertEquals(str.compareTo("I AM A NUMBER ONE!") == 0, __); + assertEquals(str.compareTo("I AM a number ONE!") == 0, true); + assertEquals(str.compareTo("I am a number one!") == 0, false); + assertEquals(str.compareTo("I AM A NUMBER ONE!") == 0, false); } @Koan public void stringCompareIgnoreCase() { String str = "I AM a number ONE!"; - assertEquals(str.compareToIgnoreCase("I AM a number ONE!") == 0, __); - assertEquals(str.compareToIgnoreCase("I am a number one!") == 0, __); - assertEquals(str.compareToIgnoreCase("I AM A NUMBER ONE!") == 0, __); + assertEquals(str.compareToIgnoreCase("I AM a number ONE!") == 0, true); + assertEquals(str.compareToIgnoreCase("I am a number one!") == 0, true); + assertEquals(str.compareToIgnoreCase("I AM A NUMBER ONE!") == 0, true); } @Koan public void stringStartsWith() { - assertEquals("".startsWith("one"), __); - assertEquals("one".startsWith("one"), __); - assertEquals("one is the number".startsWith("one"), __); - assertEquals("ONE is the number".startsWith("one"), __); + assertEquals("".startsWith("one"), false); + assertEquals("one".startsWith("one"), true); + assertEquals("one is the number".startsWith("one"), true); + assertEquals("ONE is the number".startsWith("one"), false); } @Koan public void stringEndsWith() { - assertEquals("".endsWith("one"), __); - assertEquals("one".endsWith("one"), __); - assertEquals("the number is one".endsWith("one"), __); - assertEquals("the number is two".endsWith("one"), __); - assertEquals("the number is One".endsWith("one"), __); + assertEquals("".endsWith("one"), false); + assertEquals("one".endsWith("one"), true); + assertEquals("the number is one".endsWith("one"), true); + assertEquals("the number is two".endsWith("one"), false); + assertEquals("the number is One".endsWith("one"), false); } @Koan public void stringSubstring() { String str = "I AM a number ONE!"; - assertEquals(str.substring(0), __); - assertEquals(str.substring(1), __); - assertEquals(str.substring(5), __); - assertEquals(str.substring(14, 17), __); - assertEquals(str.substring(7, str.length()), __); + assertEquals(str.substring(0), "I AM a number ONE!"); + assertEquals(str.substring(1), " AM a number ONE!"); + assertEquals(str.substring(5), "a number ONE!"); + assertEquals(str.substring(14, 17), "ONE"); + assertEquals(str.substring(7, str.length()), "number ONE!"); } @Koan public void stringContains() { String str = "I AM a number ONE!"; - assertEquals(str.contains("one"), __); - assertEquals(str.contains("ONE"), __); + assertEquals(str.contains("one"), false); + assertEquals(str.contains("ONE"), true); } @Koan public void stringReplace() { String str = "I am a number ONE!"; - assertEquals(str.replace("ONE", "TWO"), __); - assertEquals(str.replace("I am", "She is"), __); + assertEquals(str.replace("ONE", "TWO"), "I am a number TWO!"); + assertEquals(str.replace("I am", "She is"), "She is a number ONE!"); } @Koan public void stringBuilderCanActAsAMutableString() { - assertEquals(new StringBuilder("one").append(" ").append("two").toString(), __); + assertEquals(new StringBuilder("one").append(" ").append("two").toString(), "one two"); } @Koan public void readableStringFormattingWithStringFormat() { - assertEquals(String.format("%s %s %s", "a", "b", "a"), __); + assertEquals(String.format("%s %s %s", "a", "b", "a"), "a b a"); } @Koan public void extraArgumentsToStringFormatGetIgnored() { - assertEquals(String.format("%s %s %s", "a", "b", "c", "d"), __); + assertEquals(String.format("%s %s %s", "a", "b", "c", "d"), "a b c"); } @Koan @@ -164,23 +164,23 @@ public void insufficientArgumentsToStringFormatCausesAnError() { String.format("%s %s %s", "a", "b"); fail("No Exception was thrown!"); } catch (Exception e) { - assertEquals(e.getClass(), __); - assertEquals(e.getMessage(), __); + assertEquals(e.getClass(), java.util.MissingFormatArgumentException.class); + assertEquals(e.getMessage(), "Format specifier '%s'"); } } @Koan public void readableStringFormattingWithMessageFormat() { - assertEquals(MessageFormat.format("{0} {1} {0}", "a", "b"), __); + assertEquals(MessageFormat.format("{0} {1} {0}", "a", "b"), "a b a"); } @Koan public void extraArgumentsToMessageFormatGetIgnored() { - assertEquals(MessageFormat.format("{0} {1} {0}", "a", "b", "c"), __); + assertEquals(MessageFormat.format("{0} {1} {0}", "a", "b", "c"), "a b a"); } @Koan public void insufficientArgumentsToMessageFormatDoesNotReplaceTheToken() { - assertEquals(MessageFormat.format("{0} {1} {0}", "a"), __); + assertEquals(MessageFormat.format("{0} {1} {0}", "a"), "a {1} a"); } } diff --git a/koans/src/beginner/AboutVarArgs.java b/koans/src/beginner/AboutVarArgs.java index d187336b..47575162 100644 --- a/koans/src/beginner/AboutVarArgs.java +++ b/koans/src/beginner/AboutVarArgs.java @@ -29,22 +29,22 @@ public String verboseLength(String prefix, Object... arguments) { @Koan public void varArgsCanBeTreatedAsArrays() { - assertEquals(new ExampleClass().canBeTreatedAsArray(1, 2, 3), __); + assertEquals(new ExampleClass().canBeTreatedAsArray(1, 2, 3), true); } @Koan public void youCanPassInAsManyArgumentsAsYouLike() { - assertEquals(new ExampleClass().getLength(1, 2, 3), __); - assertEquals(new ExampleClass().getLength(1, 2, 3, 4, 5, 6, 7, 8), __); + assertEquals(new ExampleClass().getLength(1, 2, 3), 3); + assertEquals(new ExampleClass().getLength(1, 2, 3, 4, 5, 6, 7, 8), 8); } @Koan public void youCanPassInZeroArgumentsIfYouLike() { - assertEquals(new ExampleClass().getLength(), __); + assertEquals(new ExampleClass().getLength(), 0); } @Koan public void youCanHaveOtherTypesInTheMethodSignature() { - assertEquals(new ExampleClass().verboseLength("This is how many items were passed in: ", 1, 2, 3, 4), __); + assertEquals(new ExampleClass().verboseLength("This is how many items were passed in: ", 1, 2, 3, 4), "This is how many items were passed in: 4"); } } diff --git a/koans/src/intermediate/AboutAutoboxing.java b/koans/src/intermediate/AboutAutoboxing.java index 4063eb2d..bf19477f 100755 --- a/koans/src/intermediate/AboutAutoboxing.java +++ b/koans/src/intermediate/AboutAutoboxing.java @@ -14,39 +14,39 @@ public class AboutAutoboxing { public void addPrimitivesToCollection() { List list = new ArrayList(); list.add(0, new Integer(42)); - assertEquals(list.get(0), __); + assertEquals(list.get(0), 42); } @Koan public void addPrimitivesToCollectionWithAutoBoxing() { List list = new ArrayList(); list.add(0, 42); - assertEquals(list.get(0), __); + assertEquals(list.get(0), 42); } @Koan public void migrateYourExistingCodeToAutoBoxingWithoutFear() { List list = new ArrayList(); list.add(0, new Integer(42)); - assertEquals(list.get(0), __); + assertEquals(list.get(0), 42); list.add(1, 84); - assertEquals(list.get(1), __); + assertEquals(list.get(1), 84); } @Koan public void allPrimitivesCanBeAutoboxed() { List doubleList = new ArrayList(); doubleList.add(0, new Double(42)); - assertEquals(doubleList.get(0), __); + assertEquals(doubleList.get(0), 42.0); List longList = new ArrayList(); longList.add(0, new Long(42)); - assertEquals(longList.get(0), __); + assertEquals(longList.get(0), 42l); List characterList = new ArrayList(); characterList.add(0, new Character('z')); - assertEquals(characterList.get(0), __); + assertEquals(characterList.get(0), 'z'); } } diff --git a/koans/src/intermediate/AboutCollections.java b/koans/src/intermediate/AboutCollections.java index 3d4cca35..78720cef 100644 --- a/koans/src/intermediate/AboutCollections.java +++ b/koans/src/intermediate/AboutCollections.java @@ -21,9 +21,9 @@ public void usingAnArrayList() { list.add("Chicken"); list.add("Dog"); list.add("Chicken"); - assertEquals(list.get(0), __); - assertEquals(list.get(1), __); - assertEquals(list.get(2), __); + assertEquals(list.get(0), "Chicken"); + assertEquals(list.get(1), "Dog"); + assertEquals(list.get(2), "Chicken"); } @Koan @@ -33,12 +33,12 @@ public void usingAQueue() { // PriorityQueue: simple queue implementation queue.add("Cat"); queue.add("Dog"); - assertEquals(queue.peek(), __); - assertEquals(queue.size(), __); - assertEquals(queue.poll(), __); - assertEquals(queue.size(), __); - assertEquals(queue.poll(), __); - assertEquals(queue.isEmpty(), __); + assertEquals(queue.peek(), "Cat"); + assertEquals(queue.size(), 2); + assertEquals(queue.poll(), "Cat"); + assertEquals(queue.size(), 1); + assertEquals(queue.poll(), "Dog"); + assertEquals(queue.isEmpty(), true); } @Koan @@ -47,10 +47,10 @@ public void usingABasicSet() { set.add("Dog"); set.add("Cat"); set.add("Dog"); - assertEquals(set.size(), __); - assertEquals(set.contains("Dog"), __); - assertEquals(set.contains("Cat"), __); - assertEquals(set.contains("Chicken"), __); + assertEquals(set.size(), 2); + assertEquals(set.contains("Dog"), true); + assertEquals(set.contains("Cat"), true); + assertEquals(set.contains("Chicken"), false); } @Koan @@ -59,11 +59,11 @@ public void usingABasicMap() { map.put("first key", "first value"); map.put("second key", "second value"); map.put("first key", "other value"); - assertEquals(map.size(), __); - assertEquals(map.containsKey("first key"), __); - assertEquals(map.containsKey("second key"), __); - assertEquals(map.containsValue("first value"), __); - assertEquals(map.get("first key"), __); + assertEquals(map.size(), 2); + assertEquals(map.containsKey("first key"), true); + assertEquals(map.containsKey("second key"), true); + assertEquals(map.containsValue("first value"), false); + assertEquals(map.get("first key"), "other value"); } @Koan @@ -71,9 +71,9 @@ public void usingBackedArrayList() { String[] array = {"a", "b", "c"}; List list = Arrays.asList(array); list.set(0, "x"); - assertEquals(array[0], __); + assertEquals(array[0], "x"); array[0] = "a"; - assertEquals(list.get(0), __); + assertEquals(list.get(0), "a"); // Just think of it as quantum state teleportation... } @@ -86,12 +86,12 @@ public void usingBackedSubMap() { map.put("e", "Emu"); map.put("f", "Fox"); SortedMap backedMap = map.subMap("c", "f"); - assertEquals(backedMap.size(), __); - assertEquals(map.size(), __); + assertEquals(backedMap.size(), 2); + assertEquals(map.size(), 5); backedMap.put("d", "Dog"); - assertEquals(backedMap.size(), __); - assertEquals(map.size(), __); - assertEquals(map.containsKey("d"), __); + assertEquals(backedMap.size(), 3); + assertEquals(map.size(), 6); + assertEquals(map.containsKey("d"), true); // Again: backed maps are just like those little quantum states // that are connected forever... } @@ -102,8 +102,8 @@ public void differenceBetweenOrderedAndSorted() { sorted.add("c"); sorted.add("z"); sorted.add("a"); - assertEquals(sorted.first(), __); - assertEquals(sorted.last(), __); + assertEquals(sorted.first(), "a"); + assertEquals(sorted.last(), "z"); // Look at the different constructors for a TreeSet (or TreeMap) // Ponder how you might influence the sort order. Hold that thought // until you approach AboutComparison @@ -116,6 +116,6 @@ public void differenceBetweenOrderedAndSorted() { for (String s : ordered) { sb.append(s); } - assertEquals(sb.toString(), __); + assertEquals(sb.toString(), "cza"); } } diff --git a/koans/src/intermediate/AboutComparison.java b/koans/src/intermediate/AboutComparison.java index ee58ab64..c7a615a4 100644 --- a/koans/src/intermediate/AboutComparison.java +++ b/koans/src/intermediate/AboutComparison.java @@ -14,9 +14,9 @@ public class AboutComparison { public void compareObjects() { String a = "abc"; String b = "bcd"; - assertEquals(a.compareTo(b), __); - assertEquals(a.compareTo(a), __); - assertEquals(b.compareTo(a), __); + assertEquals(a.compareTo(b), -1); + assertEquals(a.compareTo(a), 0); + assertEquals(b.compareTo(a), 1); } static class Car implements Comparable { @@ -36,7 +36,7 @@ public void makeObjectsComparable() { vwbeetle.horsepower = 50; Car porsche = new Car(); porsche.horsepower = 300; - assertEquals(vwbeetle.compareTo(porsche), __); + assertEquals(vwbeetle.compareTo(porsche), -250); } static class RaceHorse { @@ -76,8 +76,8 @@ public void makeObjectsComparableWithoutComparable() { RaceHorse[] horses = {lindy, slowy, lightning}; Arrays.sort(horses, new HorseAgeComparator()); - assertEquals(horses[0], __); + assertEquals(horses[0], lightning); Arrays.sort(horses, new HorseSpeedComparator()); - assertEquals(horses[0], __); + assertEquals(horses[0], slowy); } }