trackler 2.2.1.106 → 2.2.1.107

data/tracks/go/exercises/proverb/example.go

@@ -0,0 +1,19 @@
+// Package proverb deals with outputting the lines of a rhyme.
+package proverb
+
+import "fmt"
+
+// Proverb outputs the lines of for want of a nail
+func Proverb(rhyme []string) []string {
+	if len(rhyme) == 0 {
+		return []string{}
+	}
+	var r []string
+	if len(rhyme) > 1 {
+		for i := 0; i < len(rhyme)-1; i++ {
+			r = append(r, fmt.Sprintf("For want of a %s the %s was lost.", rhyme[i], rhyme[i+1]))
+		}
+	}
+	r = append(r, fmt.Sprintf("And all for the want of a %s.", rhyme[0]))
+	return r
+}

data/tracks/go/exercises/proverb/proverb.go

@@ -0,0 +1,15 @@
+// This is a "stub" file.  It's a little start on your solution.
+// It's not a complete solution though; you have to write some code.
+
+// Package proverb should have a package comment that summarizes what it's about.
+// https://golang.org/doc/effective_go.html#commentary
+package proverb
+
+// Proverb should have a comment documenting it.
+func Proverb(rhyme []string) []string {
+	// Write some code here to pass the test suite.
+	// Then remove all the stock comments.
+	// They're here to help you get started but they only clutter a finished solution.
+	// If you leave them in, reviewers may protest!
+	return []string{}
+}

data/tracks/go/exercises/proverb/proverb_test.go

@@ -0,0 +1,23 @@
+package proverb
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestProverb(t *testing.T) {
+	for _, test := range stringTestCases {
+		actual := Proverb(test.input)
+		if fmt.Sprintf("%q", actual) != fmt.Sprintf("%q", test.expected) {
+			t.Fatalf("Proverb test [%s], expected [%s], actual [%s]", test.input, test.expected, actual)
+		}
+	}
+}
+
+func BenchmarkProverb(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range stringTestCases {
+			Proverb(test.input)
+		}
+	}
+}

data/tracks/julia/exercises/isbn-verifier/example.jl

@@ -8,6 +8,8 @@ struct ISBN <: AbstractString
     ISBN(s) = verify(s) ? new(replace(s, "-", "")) : throw(ArgumentError("invalid ISBN string: $s"))
 end
 
+string(s::ISBN) = s.s
+
 function verify(s::AbstractString)
     s = replace(s, "-", "")
     chars = split(s, "")

data/tracks/julia/exercises/isbn-verifier/runtests.jl

@@ -40,13 +40,13 @@ end
 
 @testset "constructing valid ISBN numbers" begin
     # ISBN number
-    @test isbn"3-598-21508-8".s == "3598215088"
+    @test string(isbn"3-598-21508-8") == "3598215088"
     # ISBN number with a check digit of 10
-    @test isbn"3-598-21507-X".s == "359821507X"
+    @test string(isbn"3-598-21507-X") == "359821507X"
     # ISBN without separating dashes
-    @test isbn"3598215088".s == "3598215088"
+    @test string(isbn"3598215088") == "3598215088"
     # ISBN without separating dashes and X as check digit
-    @test isbn"359821507X".s == "359821507X"
+    @test string(isbn"359821507X") == "359821507X"
 end
 
 @testset "constructing invalid ISBN numbers" begin

data/tracks/rust/exercises/two-bucket/README.md

@@ -27,7 +27,7 @@ To conclude, the only valid moves are:
 - emptying one bucket and doing nothing to the other
 - filling one bucket and doing nothing to the other
 
-Written with <3 at [Fullstack Academy](http://www.fullstackacademy.com/) by [Lindsay](http://lindsaylevine.com).
+Written with <3 at [Fullstack Academy](http://www.fullstackacademy.com/) by Lindsay Levine.
 
 ## Rust Installation
 

data/tracks/scala/exercises/bracket-push/src/test/scala/BracketPushTest.scala

@@ -1,74 +1,76 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.1.0 */
+/** @version 1.2.0 */
 class BracketPushTest extends FunSuite with Matchers {
 
   test("paired square brackets") {
-    BracketPush.isPaired("[]") should be (true)
+    BracketPush.isPaired("[]") should be(true)
   }
 
   test("empty string") {
     pending
-    BracketPush.isPaired("") should be (true)
+    BracketPush.isPaired("") should be(true)
   }
 
   test("unpaired brackets") {
     pending
-    BracketPush.isPaired("[[") should be (false)
+    BracketPush.isPaired("[[") should be(false)
   }
 
   test("wrong ordered brackets") {
     pending
-    BracketPush.isPaired("}{") should be (false)
+    BracketPush.isPaired("}{") should be(false)
   }
 
   test("wrong closing bracket") {
     pending
-    BracketPush.isPaired("{]") should be (false)
+    BracketPush.isPaired("{]") should be(false)
   }
 
   test("paired with whitespace") {
     pending
-    BracketPush.isPaired("{ }") should be (true)
+    BracketPush.isPaired("{ }") should be(true)
   }
 
   test("simple nested brackets") {
     pending
-    BracketPush.isPaired("{[]}") should be (true)
+    BracketPush.isPaired("{[]}") should be(true)
   }
 
   test("several paired brackets") {
     pending
-    BracketPush.isPaired("{}[]") should be (true)
+    BracketPush.isPaired("{}[]") should be(true)
   }
 
   test("paired and nested brackets") {
     pending
-    BracketPush.isPaired("([{}({}[])])") should be (true)
+    BracketPush.isPaired("([{}({}[])])") should be(true)
   }
 
   test("unopened closing brackets") {
     pending
-    BracketPush.isPaired("{[)][]}") should be (false)
+    BracketPush.isPaired("{[)][]}") should be(false)
   }
 
   test("unpaired and nested brackets") {
     pending
-    BracketPush.isPaired("([{])") should be (false)
+    BracketPush.isPaired("([{])") should be(false)
   }
 
   test("paired and wrong nested brackets") {
     pending
-    BracketPush.isPaired("[({]})") should be (false)
+    BracketPush.isPaired("[({]})") should be(false)
   }
 
   test("math expression") {
     pending
-    BracketPush.isPaired("(((185 + 223.85) * 15) - 543)/2") should be (true)
+    BracketPush.isPaired("(((185 + 223.85) * 15) - 543)/2") should be(true)
   }
 
   test("complex latex expression") {
     pending
-    BracketPush.isPaired("\\\\left(\\\\begin{array}{cc} \\\\frac{1}{3} & x\\\\\\\\ \\\\mathrm{e}^{x} &... x^2 \\\\end{array}\\\\right)") should be (true)
+    BracketPush.isPaired(
+      "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)") should be(
+      true)
   }
 }

data/tracks/scala/exercises/change/src/test/scala/ChangeTest.scala

@@ -1,8 +1,8 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.1.0 */
+/** @version 1.2.0 */
 class ChangeTest extends FunSuite with Matchers {
-
+  
   test("single coin change") {
     Change.findFewestCoins(25, List(1, 5, 10, 25, 100)) should be (Some(List(25)))
   }

data/tracks/scala/exercises/collatz-conjecture/src/test/scala/CollatzConjectureTest.scala

@@ -1,8 +1,8 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.1.1 */
+/** @version 1.2.0 */
 class CollatzConjectureTest extends FunSuite with Matchers {
-  
+
   test("zero steps for one") {
     CollatzConjecture.steps(1) should be (Some(0))
   }

data/tracks/scala/exercises/connect/src/test/scala/ConnectTest.scala

@@ -1,6 +1,6 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.1.0 */
 class ConnectTest extends FunSuite with Matchers {
 
   // Filter readable board into valid input

data/tracks/scala/exercises/crypto-square/src/test/scala/CryptoSquareTest.scala

@@ -1,64 +1,43 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 2.0.0 */
+/** @version 3.2.0 */
 class CryptoSquareTest extends FunSuite with Matchers {
 
-  test("Lowercase") {
-    CryptoSquare.normalizedPlaintext("Hello") should be ("hello")
-  }
-
-  test("Remove spaces") {
-    pending
-    CryptoSquare.normalizedPlaintext("Hi there") should be ("hithere")
-  }
-
-  test("Remove punctuation") {
-    pending
-    CryptoSquare.normalizedPlaintext("@1, 2%, 3 Go!") should be ("123go")
-  }
-
-  test("empty plaintext results in an empty rectangle") {
-    pending
-    CryptoSquare.plaintextSegments("") should be (List())
-  }
-
-  test("4 character plaintext results in an 2x2 rectangle") {
-    pending
-    CryptoSquare.plaintextSegments("Ab Cd") should be (List("ab", "cd"))
-  }
-
-  test("9 character plaintext results in an 3x3 rectangle") {
-    pending
-    CryptoSquare.plaintextSegments("This is fun!") should be (List("thi", "sis", "fun"))
+  test("empty plaintext results in an empty ciphertext") {
+    CryptoSquare.ciphertext("") should be("")
   }
 
-  test("54 character plaintext results in an 8x7 rectangle") {
+  test("Lowercase") {
     pending
-    CryptoSquare.plaintextSegments("If man was meant to stay on the ground, god would have given us roots.") should be (List("ifmanwas", "meanttos", "tayonthe", "groundgo", "dwouldha", "vegivenu", "sroots"))
+    CryptoSquare.ciphertext("A") should be("a")
   }
 
-  test("empty plaintext results in an empty encode") {
+  test("Remove spaces") {
     pending
-    CryptoSquare.encoded("") should be ("")
+    CryptoSquare.ciphertext("  b ") should be("b")
   }
 
-  test("Non-empty plaintext results in the combined plaintext segments") {
+  test("Remove punctuation") {
     pending
-    CryptoSquare.encoded("If man was meant to stay on the ground, god would have given us roots.") should be ("imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau")
+    CryptoSquare.ciphertext("@1,%!") should be("1")
   }
 
-  test("empty plaintext results in an empty ciphertext") {
+  test("9 character plaintext results in 3 chunks of 3 characters") {
     pending
-    CryptoSquare.ciphertext("") should be ("")
+    CryptoSquare.ciphertext("This is fun!") should be("tsf hiu isn")
   }
 
-  test("9 character plaintext results in 3 chunks of 3 characters") {
+  test(
+    "8 character plaintext results in 3 chunks, the last one with a trailing space") {
     pending
-    CryptoSquare.ciphertext("This is fun!") should be ("tsf hiu isn")
+    CryptoSquare.ciphertext("Chill out.") should be("clu hlt io ")
   }
 
-  test("54 character plaintext results in 7 chunks, the last two padded with spaces") {
+  test(
+    "54 character plaintext results in 7 chunks, the last two with trailing spaces") {
     pending
-    CryptoSquare.ciphertext("If man was meant to stay on the ground, god would have given us roots.") should be ("imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau ")
+    CryptoSquare.ciphertext(
+      "If man was meant to stay on the ground, god would have given us roots.") should be(
+      "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau ")
   }
-}
+}

data/tracks/scala/exercises/custom-set/src/test/scala/CustomSetTest.scala

@@ -1,37 +1,37 @@
 import org.scalatest.{FunSuite, Matchers}
 
-/** @version 1.0.1 */
+/** @version 1.3.0 */
 class CustomSetTest extends FunSuite with Matchers {
 
   // Empty test cases - Returns true if the set contains no elements
   test("sets with no elements are empty") {
     val set = CustomSet.fromList(List())
-    CustomSet.empty(set) should be (true)
+    CustomSet.empty(set) should be(true)
   }
 
   test("sets with elements are not empty") {
     pending
     val set = CustomSet.fromList(List(1))
-    CustomSet.empty(set) should be (false)
+    CustomSet.empty(set) should be(false)
   }
 
   // Contains test cases - Sets can report if they contain an element
   test("nothing is contained in an empty set") {
     pending
     val set = CustomSet.fromList(List())
-    CustomSet.member(set, 1) should be (false)
+    CustomSet.member(set, 1) should be(false)
   }
 
   test("when the element is in the set") {
     pending
     val set = CustomSet.fromList(List(1, 2, 3))
-    CustomSet.member(set, 1) should be (true)
+    CustomSet.member(set, 1) should be(true)
   }
 
   test("when the element is not in the set") {
     pending
     val set = CustomSet.fromList(List(1, 2, 3))
-    CustomSet.member(set, 4) should be (false)
+    CustomSet.member(set, 4) should be(false)
   }
 
   // Subset test cases - A set is a subset if all of its elements are contained in the other set
@@ -39,42 +39,42 @@ class CustomSetTest extends FunSuite with Matchers {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
-    CustomSet.isSubsetOf(set1, set2) should be (true)
+    CustomSet.isSubsetOf(set1, set2) should be(true)
   }
 
   test("empty set is a subset of non-empty set") {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1))
-    CustomSet.isSubsetOf(set1, set2) should be (true)
+    CustomSet.isSubsetOf(set1, set2) should be(true)
   }
 
   test("non-empty set is not a subset of empty set") {
     pending
     val set1 = CustomSet.fromList(List(1))
     val set2 = CustomSet.fromList(List())
-    CustomSet.isSubsetOf(set1, set2) should be (false)
+    CustomSet.isSubsetOf(set1, set2) should be(false)
   }
 
   test("set is a subset of set with exact same elements") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(1, 2, 3))
-    CustomSet.isSubsetOf(set1, set2) should be (true)
+    CustomSet.isSubsetOf(set1, set2) should be(true)
   }
 
   test("set is a subset of larger set with same elements") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 1, 2, 3))
-    CustomSet.isSubsetOf(set1, set2) should be (true)
+    CustomSet.isSubsetOf(set1, set2) should be(true)
   }
 
   test("set is not a subset of set that does not contain its elements") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 1, 3))
-    CustomSet.isSubsetOf(set1, set2) should be (false)
+    CustomSet.isSubsetOf(set1, set2) should be(false)
   }
 
   // Disjoint test cases - Sets are disjoint if they share no elements
@@ -82,35 +82,35 @@ class CustomSetTest extends FunSuite with Matchers {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
-    CustomSet.isDisjointFrom(set1, set2) should be (true)
+    CustomSet.isDisjointFrom(set1, set2) should be(true)
   }
 
   test("empty set is disjoint with non-empty set") {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1))
-    CustomSet.isDisjointFrom(set1, set2) should be (true)
+    CustomSet.isDisjointFrom(set1, set2) should be(true)
   }
 
   test("non-empty set is disjoint with empty set") {
     pending
     val set1 = CustomSet.fromList(List(1))
     val set2 = CustomSet.fromList(List())
-    CustomSet.isDisjointFrom(set1, set2) should be (true)
+    CustomSet.isDisjointFrom(set1, set2) should be(true)
   }
 
   test("sets are not disjoint if they share an element") {
     pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(2, 3))
-    CustomSet.isDisjointFrom(set1, set2) should be (false)
+    CustomSet.isDisjointFrom(set1, set2) should be(false)
   }
 
   test("sets are disjoint if they share no elements") {
     pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(3, 4))
-    CustomSet.isDisjointFrom(set1, set2) should be (true)
+    CustomSet.isDisjointFrom(set1, set2) should be(true)
   }
 
   // Equal test cases - Sets with the same elements are equal
@@ -118,35 +118,42 @@ class CustomSetTest extends FunSuite with Matchers {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
-    CustomSet.isEqual(set1, set2) should be (true)
+    CustomSet.isEqual(set1, set2) should be(true)
   }
 
   test("empty set is not equal to non-empty set") {
     pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1, 2, 3))
-    CustomSet.isEqual(set1, set2) should be (false)
+    CustomSet.isEqual(set1, set2) should be(false)
   }
 
   test("non-empty set is not equal to empty set") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List())
-    CustomSet.isEqual(set1, set2) should be (false)
+    CustomSet.isEqual(set1, set2) should be(false)
   }
 
   test("sets with the same elements are equal") {
     pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(2, 1))
-    CustomSet.isEqual(set1, set2) should be (true)
+    CustomSet.isEqual(set1, set2) should be(true)
   }
 
   test("sets with different elements are not equal") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(1, 2, 4))
-    CustomSet.isEqual(set1, set2) should be (false)
+    CustomSet.isEqual(set1, set2) should be(false)
+  }
+
+  test("set is not equal to larger set with same elements") {
+    pending
+    val set1 = CustomSet.fromList(List(1, 2, 3))
+    val set2 = CustomSet.fromList(List(1, 2, 3, 4))
+    CustomSet.isEqual(set1, set2) should be(false)
   }
 
   // Add test cases - Unique elements can be added to a set
@@ -154,21 +161,21 @@ class CustomSetTest extends FunSuite with Matchers {
     pending
     val set = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(3))
-    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be (true)
+    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be(true)
   }
 
   test("add to non-empty set") {
     pending
     val set = CustomSet.fromList(List(1, 2, 4))
     val expected = CustomSet.fromList(List(1, 2, 3, 4))
-    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be (true)
+    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be(true)
   }
 
   test("adding an existing element does not change the set") {
     pending
     val set = CustomSet.fromList(List(1, 2, 3))
     val expected = CustomSet.fromList(List(1, 2, 3))
-    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be (true)
+    CustomSet.isEqual(CustomSet.insert(set, 3), expected) should be(true)
   }
 
   // Intersection test cases - Intersection returns a set of all shared elements
@@ -177,7 +184,8 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be(
+      true)
   }
 
   test("intersection of an empty set and non-empty set is an empty set") {
@@ -185,7 +193,8 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be(
+      true)
   }
 
   test("intersection of a non-empty set and an empty set is an empty set") {
@@ -193,7 +202,8 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be(
+      true)
   }
 
   test("intersection of two sets with no shared elements is an empty set") {
@@ -201,15 +211,18 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 5, 6))
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be(
+      true)
   }
 
-  test("intersection of two sets with shared elements is a set of the shared elements") {
+  test(
+    "intersection of two sets with shared elements is a set of the shared elements") {
     pending
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List(2, 3))
-    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.intersection(set1, set2), expected) should be(
+      true)
   }
 
   // Difference test cases - Difference (or Complement) of a set is a set of all elements that are only in the first set
@@ -218,7 +231,8 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be(
+      true)
   }
 
   test("difference of empty set and non-empty set is an empty set") {
@@ -226,7 +240,8 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be(
+      true)
   }
 
   test("difference of a non-empty set and an empty set is the non-empty set") {
@@ -234,15 +249,18 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(1, 2, 3, 4))
-    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be(
+      true)
   }
 
-  test("difference of two non-empty sets is a set of elements that are only in the first set") {
+  test(
+    "difference of two non-empty sets is a set of elements that are only in the first set") {
     pending
     val set1 = CustomSet.fromList(List(3, 2, 1))
     val set2 = CustomSet.fromList(List(2, 4))
     val expected = CustomSet.fromList(List(1, 3))
-    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.difference(set1, set2), expected) should be(
+      true)
   }
 
   // Union test cases - Union returns a set of all elements in either set
@@ -251,7 +269,7 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
-    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be(true)
   }
 
   test("union of an empty set and non-empty set is the non-empty set") {
@@ -259,7 +277,7 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(2))
     val expected = CustomSet.fromList(List(2))
-    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be(true)
   }
 
   test("union of a non-empty set and empty set is the non-empty set") {
@@ -267,7 +285,7 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List(1, 3))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(1, 3))
-    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be(true)
   }
 
   test("union of non-empty sets contains all unique elements") {
@@ -275,6 +293,6 @@ class CustomSetTest extends FunSuite with Matchers {
     val set1 = CustomSet.fromList(List(1, 3))
     val set2 = CustomSet.fromList(List(2, 3))
     val expected = CustomSet.fromList(List(3, 2, 1))
-    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be (true)
+    CustomSet.isEqual(CustomSet.union(set1, set2), expected) should be(true)
   }
 }