trackler 2.2.1.69 → 2.2.1.70

data/tracks/fsharp/exercises/forth/ForthTest.fs

@@ -1,113 +1,229 @@
+// This file was auto-generated based on version 1.4.0 of the canonical data.
+
 module ForthTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Forth
 
-let bind f m = 
-    match m with
-    | Choice1Of2 x -> f x
-    | Choice2Of2 x -> Choice2Of2 x
+[<Fact>]
+let ``Parsing and numbers - numbers just get pushed onto the stack`` () =
+    let expected = Some [1; 2; 3; 4; 5]
+    evaluate ["1 2 3 4 5"] |> should equal expected
 
-let map f =
-    function
-    | Choice1Of2 x -> f x |> Choice1Of2
-    | Choice2Of2 x -> Choice2Of2 x
+[<Fact(Skip = "Remove to run test")>]
+let ``Addition - can add two numbers`` () =
+    let expected = Some [3]
+    evaluate ["1 2 +"] |> should equal expected
 
-let run text = eval text empty |> map formatStack
-    
-// Note: we use the Choice<'T1, 'T2> type to represent a possible outcome of
-// evaluating input. When the evaluating is succesful, the result is 
-// contained in a Choice1Of2. If an error occured, that error is contained
-// in a Choice2Of2.
+[<Fact(Skip = "Remove to run test")>]
+let ``Addition - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["+"] |> should equal expected
 
-[<Fact>]
-let ``No input, no stack`` () =
-    formatStack empty |> should be EmptyString
+[<Fact(Skip = "Remove to run test")>]
+let ``Addition - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 +"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtraction - can subtract two numbers`` () =
+    let expected = Some [-1]
+    evaluate ["3 4 -"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtraction - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["-"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtraction - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 -"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiplication - can multiply two numbers`` () =
+    let expected = Some [8]
+    evaluate ["2 4 *"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiplication - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["*"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiplication - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 *"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Division - can divide two numbers`` () =
+    let expected = Some [4]
+    evaluate ["12 3 /"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Numbers just get pushed onto the stack`` () =
-    run "1 2 3 4 5" |> should equal (Choice1Of2 "1 2 3 4 5": Choice<string,ForthError>)
+let ``Division - performs integer division`` () =
+    let expected = Some [2]
+    evaluate ["8 3 /"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Non-word characters are separators`` () =
-    run "1\b2\t3\n4\r5 6\t7" |> should equal (Choice1Of2 "1 2 3 4 5 6 7": Choice<string,ForthError>)
+let ``Division - errors if dividing by zero`` () =
+    let expected = None
+    evaluate ["4 0 /"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Basic arithmetic`` () =
-    run "1 2 + 4 -" |> should equal (Choice1Of2 "-1": Choice<string,ForthError>)
-    run "2 4 * 3 /" |> should equal (Choice1Of2 "2": Choice<string,ForthError>)
+let ``Division - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["/"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Division by zero`` () =
-    run "4 2 2 - /" |> should equal (Choice2Of2 DivisionByZero: Choice<string,ForthError>)
+let ``Division - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 /"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``dup`` () =
-    run "1 DUP" |> should equal (Choice1Of2 "1 1": Choice<string,ForthError>)
-    run "1 2 Dup" |> should equal (Choice1Of2 "1 2 2": Choice<string,ForthError>)
-    run "dup" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+let ``Combined arithmetic - addition and subtraction`` () =
+    let expected = Some [-1]
+    evaluate ["1 2 + 4 -"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``drop`` () =
-    run "1 drop" |> should equal (Choice1Of2 "": Choice<string,ForthError>)
-    run "1 2 drop" |> should equal (Choice1Of2 "1": Choice<string,ForthError>)
-    run "drop" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+let ``Combined arithmetic - multiplication and division`` () =
+    let expected = Some [2]
+    evaluate ["2 4 * 3 /"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``swap`` () =
-    run "1 2 swap" |> should equal (Choice1Of2 "2 1": Choice<string,ForthError>)
-    run "1 2 3 swap" |> should equal (Choice1Of2 "1 3 2": Choice<string,ForthError>)
-    run "1 swap" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
-    run "swap" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+let ``Dup - copies a value on the stack`` () =
+    let expected = Some [1; 1]
+    evaluate ["1 dup"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``over`` () =
-    run "1 2 over" |> should equal (Choice1Of2 "1 2 1": Choice<string,ForthError>)
-    run "1 2 3 over" |> should equal (Choice1Of2 "1 2 3 2": Choice<string,ForthError>)
-    run "1 over" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
-    run "over" |> should equal (Choice2Of2 StackUnderflow: Choice<string,ForthError>)
+let ``Dup - copies the top value on the stack`` () =
+    let expected = Some [1; 2; 2]
+    evaluate ["1 2 dup"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Defining a new word`` () =
-    let actual =
-        empty
-        |> eval ": dup-twice dup dup ;"  
-        |> bind (eval "1 dup-twice")
-        |> map formatStack
+let ``Dup - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["dup"] |> should equal expected
 
-    actual |> should equal (Choice1Of2 "1 1 1": Choice<string,ForthError>)
+[<Fact(Skip = "Remove to run test")>]
+let ``Drop - removes the top value on the stack if it is the only one`` () =
+    let expected: int list option = Some []
+    evaluate ["1 drop"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Redefining an existing word`` () =    
-    let actual =
-        empty
-        |> eval ": foo dup ;"  
-        |> bind (eval ": foo dup dup ;")
-        |> bind (eval "1 foo")
-        |> map formatStack
-        
-    actual |> should equal (Choice1Of2 "1 1 1": Choice<string,ForthError>)
+let ``Drop - removes the top value on the stack if it is not the only one`` () =
+    let expected = Some [1]
+    evaluate ["1 2 drop"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Redefining an existing built-in word`` () =  
-    let actual =
-        empty
-        |> eval ": swap dup ;"  
-        |> bind (eval "1 swap")
-        |> map formatStack
+let ``Drop - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["drop"] |> should equal expected
 
-    actual |> should equal (Choice1Of2 "1 1": Choice<string,ForthError>)
+[<Fact(Skip = "Remove to run test")>]
+let ``Swap - swaps the top two values on the stack if they are the only ones`` () =
+    let expected = Some [2; 1]
+    evaluate ["1 2 swap"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Swap - swaps the top two values on the stack if they are not the only ones`` () =
+    let expected = Some [1; 3; 2]
+    evaluate ["1 2 3 swap"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Swap - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["swap"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Swap - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 swap"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Defining words with odd characters`` () =
-    run ": € 220371 ; €" |> should equal (Choice1Of2 "220371": Choice<string,ForthError>)
+let ``Over - copies the second element if there are only two`` () =
+    let expected = Some [1; 2; 1]
+    evaluate ["1 2 over"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Defining a number`` () =
-    run ": 1 2 ;" |> should equal (Choice2Of2 InvalidWord: Choice<string,ForthError>)
+let ``Over - copies the second element if there are more than two`` () =
+    let expected = Some [1; 2; 3; 2]
+    evaluate ["1 2 3 over"] |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Calling a non-existing word`` () =
-    run "1 foo" |> should equal (Choice2Of2 (UnknownWord "foo"): Choice<string,ForthError>)
+let ``Over - errors if there is nothing on the stack`` () =
+    let expected = None
+    evaluate ["over"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Over - errors if there is only one value on the stack`` () =
+    let expected = None
+    evaluate ["1 over"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - can consist of built-in words`` () =
+    let expected = Some [1; 1; 1]
+    evaluate [": dup-twice dup dup ;"; "1 dup-twice"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - execute in the right order`` () =
+    let expected = Some [1; 2; 3]
+    evaluate [": countup 1 2 3 ;"; "countup"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - can override other user-defined words`` () =
+    let expected = Some [1; 1; 1]
+    evaluate [": foo dup ;"; ": foo dup dup ;"; "1 foo"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - can override built-in words`` () =
+    let expected = Some [1; 1]
+    evaluate [": swap dup ;"; "1 swap"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - can override built-in operators`` () =
+    let expected = Some [12]
+    evaluate [": + * ;"; "3 4 +"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - cannot redefine numbers`` () =
+    let expected = None
+    evaluate [": 1 2 ;"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``User-defined words - errors if executing a non-existent word`` () =
+    let expected = None
+    evaluate ["foo"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - DUP is case-insensitive`` () =
+    let expected = Some [1; 1; 1; 1]
+    evaluate ["1 DUP Dup dup"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - DROP is case-insensitive`` () =
+    let expected = Some [1]
+    evaluate ["1 2 3 4 DROP Drop drop"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - SWAP is case-insensitive`` () =
+    let expected = Some [2; 3; 4; 1]
+    evaluate ["1 2 SWAP 3 Swap 4 swap"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - OVER is case-insensitive`` () =
+    let expected = Some [1; 2; 1; 2; 1]
+    evaluate ["1 2 OVER Over over"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - user-defined words are case-insensitive`` () =
+    let expected = Some [1; 1; 1; 1]
+    evaluate [": foo dup ;"; "1 FOO Foo foo"] |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Case-insensitivity - definitions are case-insensitive`` () =
+    let expected = Some [1; 1; 1; 1]
+    evaluate [": SWAP DUP Dup dup ;"; "1 swap"] |> should equal expected
+

data/tracks/fsharp/exercises/markdown/MarkdownTest.fs

@@ -1,7 +1,9 @@
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 module MarkdownTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Markdown
 
@@ -10,7 +12,7 @@ let ``Parses normal text as a paragraph`` () =
     let input = "This will be a paragraph"
     let expected = "<p>This will be a paragraph</p>"
     parse input |> should equal expected
-    
+
 [<Fact>]
 let ``Parsing italics`` () =
     let input = "_This will be italic_"
@@ -57,4 +59,5 @@ let ``Unordered lists`` () =
 let ``With a little bit of everything`` () =
     let input = "# Header!\n* __Bold Item__\n* _Italic Item_"
     let expected = "<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>"
-    parse input |> should equal expected
+    parse input |> should equal expected
+

data/tracks/fsharp/generators/Exercise.fs

@@ -18,7 +18,7 @@ type Exercise() =
 
     // Convert canonical data to representation used when rendering
     abstract member ToTestClass : CanonicalData -> TestClass
-    abstract member ToTestMethod : int -> CanonicalDataCase -> TestMethod
+    abstract member ToTestMethod : int * CanonicalDataCase -> TestMethod
     abstract member ToTestMethodBody : CanonicalDataCase -> TestMethodBody  
     abstract member ToTestMethodBodyAssert : CanonicalDataCase -> TestMethodBodyAssert  
     abstract member ToTestMethodBodyAssertTemplate : CanonicalDataCase -> string
@@ -98,7 +98,7 @@ type Exercise() =
           Namespaces = ["FsUnit.Xunit"; "Xunit"] @ this.AdditionalNamespaces
           Methods = List.mapi this.RenderTestMethod canonicalData.Cases }
 
-    default this.ToTestMethod index canonicalDataCase =         
+    default this.ToTestMethod (index, canonicalDataCase) =
         { Skip = index > 0
           Name = this.RenderTestMethodName canonicalDataCase
           Body = this.RenderTestMethodBody canonicalDataCase }
@@ -124,8 +124,8 @@ type Exercise() =
         |> renderPartialTemplate "TestClass"
 
     default this.RenderTestMethod index canonicalDataCase = 
-        canonicalDataCase
-        |> this.ToTestMethod index
+        (index, canonicalDataCase)
+        |> this.ToTestMethod 
         |> renderPartialTemplate "TestMethod"
 
     default this.RenderTestMethodBody canonicalDataCase = 

data/tracks/fsharp/generators/Generators.fs

@@ -15,7 +15,10 @@ type AtbashCipher() =
 type AllYourBase() =    
     inherit Exercise()
 
-    override this.RenderExpected (canonicalDataCase, key, value) = value |> Option.ofNonError |> formatValue
+    override this.RenderExpected (canonicalDataCase, key, value) = 
+        value 
+        |> Option.ofNonError 
+        |> formatValue
 
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
@@ -269,6 +272,23 @@ type FoodChain() =
         |> Seq.map formatValue
         |> formatMultiLineList
 
+type Forth() =
+    inherit Exercise()
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["expected"]
+    
+    override this.RenderExpected (canonicalDataCase, key, value) = 
+        value 
+        |> Option.ofObj 
+        |> formatValue
+
+    override this.IdentifierTypeAnnotation (canonicalDataCase, key, value) = 
+        match value :?> JArray|> Option.ofObj |> Option.map Seq.isEmpty with 
+        | Some true -> Some "int list option"
+        | _ -> None
+
+    override this.UseFullMethodName canonicalDataCase = true
+
 type Gigasecond() =
     inherit Exercise()
 
@@ -354,6 +374,14 @@ type Leap() =
 
 type Luhn() =
     inherit Exercise()
+
+type Markdown() =
+    inherit Exercise()
+
+    override this.ToTestMethod (index, canonicalDataCase) =
+        { base.ToTestMethod (index, canonicalDataCase) with Skip = false }
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
     
 type Meetup() =
     inherit Exercise()

data/tracks/java/exercises/allergies/.meta/src/reference/java/Allergen.java

@@ -1,4 +1,4 @@
-public enum Allergen {
+enum Allergen {
     EGGS(1),
     PEANUTS(2),
     SHELLFISH(4),
@@ -14,7 +14,7 @@ public enum Allergen {
         this.score = score;
     }
 
-    public int getScore() {
+    int getScore() {
         return score;
     }
 }

data/tracks/java/exercises/allergies/.meta/src/reference/java/Allergies.java

@@ -2,21 +2,21 @@ import java.util.EnumSet;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class Allergies {
+class Allergies {
 
     private int score;
 
-    public Allergies(int score) {
+    Allergies(int score) {
         this.score = score;
     }
 
-    public List<Allergen> getList() {
+    List<Allergen> getList() {
         return EnumSet.allOf(Allergen.class).stream()
                 .filter(this::isAllergicTo)
                 .collect(Collectors.toList());
     }
 
-    public boolean isAllergicTo(Allergen allergen) {
+    boolean isAllergicTo(Allergen allergen) {
         return (score & allergen.getScore()) == allergen.getScore();
     }
 }

data/tracks/java/exercises/allergies/src/main/java/Allergen.java

@@ -1,4 +1,4 @@
-public enum Allergen {
+enum Allergen {
     EGGS(1),
     PEANUTS(2),
     SHELLFISH(4),
@@ -14,7 +14,7 @@ public enum Allergen {
         this.score = score;
     }
 
-    public int getScore() {
+    int getScore() {
         return score;
     }
 }

data/tracks/java/exercises/anagram/.meta/src/reference/java/Anagram.java

@@ -1,14 +1,14 @@
 import java.util.*;
 
-public class Anagram {
+class Anagram {
 
     private final AnagramSubject anagramSubject;
 
-    public Anagram(String word) {
+    Anagram(String word) {
         anagramSubject = new AnagramSubject(word);
     }
 
-    public List<String> match(List<String> candidates) {
+    List<String> match(List<String> candidates) {
         List<String> anagrams = new ArrayList<String>();
 
         for (String candidate : candidates) {
@@ -25,12 +25,12 @@ public class Anagram {
         private final String word;
         private final char[] fingerprint;
 
-        public AnagramSubject(String other) {
+        AnagramSubject(String other) {
             this.word = other;
             this.fingerprint = canonicalize(other);
         }
 
-        public boolean anagramOf(String other) {
+        boolean anagramOf(String other) {
             return !duplicate(other) && Arrays.equals(fingerprint,canonicalize(other));
         }
 

data/tracks/java/exercises/bob/.meta/src/reference/java/Bob.java

@@ -1,15 +1,18 @@
 /**
  * Bob is a lackadasical teenager.
  */
-public class Bob {
-    public String hey(String input) {
+class Bob {
+    String hey(String input) {
         input = normalize(input);
-        if (isSilence(input))
+        if (isSilence(input)) {
             return "Fine. Be that way!";
-        if (isShout(input))
+        }
+        if (isShout(input)) {
             return "Whoa, chill out!";
-        if (isQuestion(input))
+        }
+        if (isQuestion(input)) {
             return "Sure.";
+        }
         return "Whatever.";
     }
 

data/tracks/java/exercises/kindergarten-garden/src/main/java/KindergartenGarden.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+class KindergartenGarden {
+
+    KindergartenGarden(String garden, String[] students) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    KindergartenGarden(String garden) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<Plant> getPlantsOfStudent(String student) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/nth-prime/src/main/java/PrimeCalculator.java

@@ -0,0 +1,7 @@
+class PrimeCalculator {
+
+    int nth(int nth) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/rotational-cipher/src/main/java/RotationalCipher.java

@@ -0,0 +1,11 @@
+class RotationalCipher {
+
+    RotationalCipher(int shiftKey) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    String rotate(String data) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/javascript/config.json

@@ -1056,6 +1056,21 @@
       "unlocked_by": "prime-factors",
       "uuid" : "910fe904-7e3c-11e7-bb31-be2e44b06b34"
     },
+    {
+      "uuid": "3b779cb8-9544-4e0d-a306-e5478d741be7",
+      "slug": "connect",
+      "core": false,
+      "unlocked_by": "grade-school",
+      "difficulty": 7,
+      "topics": [
+        "Control-flow (loops)",
+        "Control-flow (conditionals)",
+        "Games",
+        "Parsing",
+        "Arrays",
+        "Maps"
+      ]
+    },
     {
       "core" :  false,
       "difficulty" : 1,

data/tracks/javascript/exercises/connect/README.md

@@ -0,0 +1,59 @@
+# Connect
+
+Compute the result for a game of Hex / Polygon.
+
+The abstract boardgame known as
+[Hex](https://en.wikipedia.org/wiki/Hex_%28board_game%29) / Polygon /
+CON-TAC-TIX is quite simple in rules, though complex in practice. Two players
+place stones on a rhombus with hexagonal fields. The player to connect his/her
+stones to the opposite side first wins. The four sides of the rhombus are
+divided between the two players (i.e. one player gets assigned a side and the
+side directly opposite it and the other player gets assigned the two other
+sides).
+
+Your goal is to build a program that given a simple representation of a board
+computes the winner (or lack thereof). Note that all games need not be "fair".
+(For example, players may have mismatched piece counts.)
+
+The boards look like this (with spaces added for readability, which won't be in
+the representation passed to your code):
+
+```        
+. O . X .
+ . X X O .
+  O O O X .
+   . X O X O
+    X O O O X
+```
+
+"Player `O`" plays from top to bottom, "Player `X`" plays from left to right. In
+the above example `O` has made a connection from left to right but nobody has
+won since `O` didn't connect top and bottom.
+
+## Setup
+
+Go through the setup instructions for JavaScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/javascript
+
+## Making the test suite pass
+
+Execute the tests with:
+
+    jasmine <exercise-name>.spec.js
+
+Replace `<exercise-name>` with the name of the current exercise. E.g., to
+test the Hello World exercise:
+
+    jasmine hello-world.spec.js
+
+In many test suites all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+changing `xit` to `it`.
+
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.