trackler 2.2.1.86 → 2.2.1.87

data/tracks/c/exercises/space-age/README.md

@@ -12,12 +12,137 @@ Given an age in seconds, calculate how old someone would be on:
    - Neptune: orbital period 164.79132 Earth years
 
 So if you were told someone were 1,000,000,000 seconds old, you should
-be able to say that they're 31.69 Earth-years old. Round all ages to
-the nearest hundredth of a year.
+be able to say that they're 31.69 Earth-years old.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
 
+## Exercises without stub implementations
+
+Like the majority of C programs you will write, this exercise comes without any header file (`*.h`) or source file (`*.c`).
+
+
+### Add the required files
+
+You will need to create these yourself as part of the exercise. 
+This is so that you get to practice deciding on and creating the program's interface yourself, which is an important part of programming in C.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+
+```bash
+make: *** No rule to make target 'src/exercise_name.c', needed by 'tests.out'.  Stop.
+```
+
+This error occurs because the `makefile` attempts to use a file that hasn't been created yet (`exercise_name.c`).
+To resolve this error you will need to add a matching file to the `src` directory.
+For example, for the error above you would add a file called `exercise_name.c`.
+
+When you try to run the tests again you will get a slightly different error.
+
+```bash
+make: *** No rule to make target 'src/exercise_name.h', needed by 'tests.out'.  Stop.
+```
+
+Again the `makefile` still needs another file that has yet to be created (`exercise_name.h`).
+The solution to this error is similar to the last, add the matching file to the `src` directory.
+For example, for the above error you would add a file called `exercise_name.h`
+
+
+### Add the required declarations
+
+Running the tests a third time you see you will get new errors, similar to:
+
+```bash
+Compiling tests.out
+src/exercise_name.c:1:0: error: ISO C forbids an empty translation unit [-Werror=pedantic]
+cc1: all warnings being treated as errors
+test/test_exercise_name.c:13:1: error: unknown type name ‘bar_t’; did you mean ‘__bar_t’?
+    bar_t b = foo(a, 2.5);
+    ^~~~~~
+ __bar_t
+test/test_exercise_name.c:15:14: error: storage size of fizz isn’t known
+    struct baz fizz;
+               ^~~~
+test/test_exercise_name.c:29:20: error: implicit declaration of function ‘foo’ [-Werror=implicit-function-declaration]
+    bar_t b = foo_function(fizz, 2.5);
+```
+
+This error means that you need to add function, type and variable decarations to the header file to match those the test file is attempting to use.
+In doing this you will need to look at the build errors and the test code to determine what needs to be declared in the header file.
+
+For example, for the error above you should declare a type named  `bar_t`, a `struct` called `baz` and a function named `foo()`. 
+Additionally we can tell from looking at the above errors that function `foo()` has two parameters. 
+
+The first parameter is passed an argument of `fizz` and thus should have a type of `struct baz`.
+The second parameter is passed `2.5` and so could have one of two types, either `float` or `double`.
+You will need to look at the test code to determine which.
+
+The _names_ of the parameters are not determined by the test code and so are left up to you to decide, though in keeping with C programming practices they should be descriptive but not overly long.
+
+Further, we can see that the the return type expected by the test code is of the type `bar_t`.
+
+Putting this all together we end up with a function declaration that looks like the following:
+
+```c
+// The parameter names are not very good here they should be more descriptive in a real exercise.
+// We have decide on a double for the second parameter in this hypothetical example.
+bar_t foo(struct baz b, double d);
+```
+
+You should continue to do this for any further similar errors.
+To check that you have correctly determined the required declaration, just run the tests again and analyse any errors similarly.
+
+Additionally, remember to add any includes to the header file any headers that it itself requires.
+
+
+### Include guards
+
+Before you are finished with the header file, you should add include guards.
+Include guards are used to help prevent the file from being included multiple times by accident.
+If the file _was_ included multiple times then the functions and other items would be declared twice; In C this is an error because the compiler thinks you are trying to declare another _different_ function that has the same name.
+
+To add include guards, add something similar to the following as the first two lines of the header:
+
+```c
+#ifndef EXERCISE_NAME_H
+#define EXERCISE_NAME_H
+```
+
+And on the very last line:
+
+```c
+#endif
+```
+
+
+### Add the required definitions
+
+Once the header file is complete you may still have build errors similar to the following:
+
+```bash
+Compiling tests.out
+src/exercise_name.c:1:0: error: ISO C forbids an empty translation unit [-Werror=pedantic]
+cc1: all warnings being treated as errors
+makefile:24: recipe for target 'tests.out' failed
+make: *** [tests.out] Error 1
+```
+
+This is because although you have _declared_ all the items you need to, they have not yet been _defined_.
+To define the needed items you need to add their implementation to the `exercise_name.c` file.
+For the function `foo()` from the previous example, this would look similar to:
+
+```c
+#include "exercise_name.h"
+
+bar_t foo(struct baz b, double d)
+{
+    // Your exercise code here
+}
+```
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 ## Getting Started
 
 Make sure you have read the

data/tracks/elisp/bin/test-examples

@@ -5,23 +5,20 @@ if [[ ! -d "exercises" ]]; then
     exit 1
 fi
 
-cd ./exercises
+tar czf exercises.tgz exercises
+pushd $_
 
+err_cnt=0
 for ex in *; do
-    err_cnt=0
-    impl="${ex}.el"
-    cd $ex
-    mv $impl "${impl}.tmp"
-    cp example.el $impl
+    pushd $ex
+    mv example.el "${ex}.el"
     emacs -batch -l ert -l "${ex}-test.el" -f ert-run-tests-batch-and-exit
     let "err_cnt += $?"
-    mv "${impl}.tmp" $impl
-    cd -
+    popd
 done
 
-if [ $err_cnt -ne 0 ]
-then
-    exit 1
-else
-    exit 0
-fi
+popd
+tar xzf exercises.tgz
+rm $_
+
+[ $err_cnt -eq 0 ] || exit 1

data/tracks/elisp/config.json

@@ -160,8 +160,16 @@
       "topics": null,
       "unlocked_by": null,
       "uuid": "d219aab6-11ec-4e0c-b041-f06c8d523946"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "acronym",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "a252e137-8a63-4f26-b119-7264f12a257a"
     }
   ],
   "foregone": [],
   "language": "Emacs Lisp"
-}
+}

data/tracks/elisp/exercises/acronym/README.md

@@ -0,0 +1,13 @@
+# Acronym
+
+Convert a phrase to its acronym.
+
+Techies love their TLA (Three Letter Acronyms)!
+
+Help generate some jargon by writing a program that converts a long name like Portable Network Graphics to its acronym (PNG).
+## Source
+
+Julien Vanier https://github.com/monkbroc
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elisp/exercises/acronym/acronym-test.el

@@ -0,0 +1,28 @@
+;;; acronym-test.el --- Tests for Acronym (exercism)
+
+;;; Commentary:
+
+;;; Code
+
+(load-file "acronym.el")
+
+(ert-deftest basic ()
+  (should (equal "PNG" (acronym "Portable Network Graphics"))))
+
+(ert-deftest lowercase-words ()
+  (should (equal "ROR" (acronym "Ruby on Rails"))))
+
+(ert-deftest punctuation ()
+  (should (equal "FIFO" (acronym "First In, First Out"))))
+
+(ert-deftest all-caps-words ()
+  (should (equal "PHP" (acronym "PHP: Hypertext Preprocessor"))))
+
+(ert-deftest non-acronym-all-caps-word ()
+  (should (equal "GIMP" (acronym "GNU Image Manipulation Program"))))
+
+(ert-deftest hyphenated ()
+  (should (equal "CMOS" (acronym "Complementary metal-oxide semiconductor"))))
+
+(provide 'acronym-test)
+;;; acronym-test.el ends here

data/tracks/elisp/exercises/acronym/acronym.el

@@ -0,0 +1,11 @@
+;;; acronym.el --- Acronym (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'cl)
+
+
+(provide 'acronym)
+;;; acronym.el ends here

data/tracks/elisp/exercises/acronym/example.el

@@ -0,0 +1,14 @@
+;;; acronym.el --- Acronym (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'cl)
+
+(defun acronym (input)
+  (let ((words (split-string input "\\W+")))
+    (mapconcat (lambda (word) (upcase (substring word 0 1))) words "")))
+
+(provide 'acronym)
+;;; acronym.el ends here

data/tracks/elisp/exercises/bob/example.el

@@ -3,12 +3,10 @@
 ;;; Commentary:
 
 ;;; Code:
-(eval-when-compile (require 'subr-x))
-
 (defun response-for (phrase)
   "Provides Bob's response to PHRASE."
   (cond ((shoutp phrase) "Whoa, chill out!")
-        ((string-blank-p phrase) "Fine. Be that way!")
+        ((string-match-p "^[[:space:]]*$" phrase) "Fine. Be that way!")
         ((questionp phrase) "Sure.")
         (t "Whatever.")))
 

data/tracks/elisp/exercises/hamming/README.md

@@ -34,9 +34,11 @@ The Hamming distance between these two DNA strands is 7.
 The Hamming distance is only defined for sequences of equal length. This means
 that based on the definition, each language could deal with getting sequences
 of equal length differently.
+
 ## Source
 
 The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elisp/exercises/hamming/hamming-test.el

@@ -1,32 +1,55 @@
 ;;; hamming-test.el --- Tests for hamming (exercism)
 
 ;;; Commentary:
+;; Common test data version: 2.0.1 f79dfd7
 
 ;;; Code:
 
 (load-file "hamming.el")
 
-(ert-deftest no-difference-between-empty-strands ()
+(declare-function hamming-distance "hamming.el")
+
+(ert-deftest empty-strands ()
   (should (= 0 (hamming-distance "" ""))))
 
-(ert-deftest no-difference-between-identical-strands ()
-  (should (= 0 (hamming-distance "GATTACA" "GATTACA"))))
+(ert-deftest identical-strands ()
+  (should (= 0 (hamming-distance "A" "A"))))
+
+(ert-deftest long-identical-strands ()
+  (should (= 0 (hamming-distance "GGACTGA" "GGACTGA"))))
+
+(ert-deftest complete-distance-in-single-nucleotide-strands ()
+  (should (= 1 (hamming-distance "A" "G"))))
+
+(ert-deftest complete-distance-in-small-strands ()
+  (should (= 2 (hamming-distance "AG" "CT"))))
 
-(ert-deftest complete-hamming-distance-in-small-strand ()
-  (should (= 3 (hamming-distance "ACT" "GGA"))))
+(ert-deftest small-distance-in-small-strands ()
+  (should (= 1 (hamming-distance "AT" "CT"))))
 
-(ert-deftest small-hamming-distance-in-middle-somwhere ()
+(ert-deftest small-distance ()
   (should (= 1 (hamming-distance "GGACG" "GGTCG"))))
 
-(ert-deftest larger-distance ()
+(ert-deftest small-distance-in-long-strands ()
   (should (= 2 (hamming-distance "ACCAGGG" "ACTATGG"))))
 
-(ert-deftest invalid-to-get-distance-for-different-length-strings ()
-  (should-error (hamming-distance "AGACAACAGCCAGCCGCCGGATT" "AGGCAA"))
-  (should-error (hamming-distance
-                 "AGACAACAGCCAGCCGCCGGATT" "AGACATCTTTCAGCCGCCGGATTAGGCAA"))
-  (should-error (hamming-distance "AGG" "CATCATCATCATCATGAT")))
+(ert-deftest non-unique-character-in-first-strand ()
+  (should (= 1 (hamming-distance "AAA" "AAG"))))
+
+(ert-deftest same-nucleotides-in-different-positions ()
+  (should (= 2 (hamming-distance "TAG" "GAT"))))
+
+(ert-deftest large-distance ()
+  (should (= 4 (hamming-distance "GATACA" "GCATAA"))))
+
+(ert-deftest large-distance-in-off-by-one-strand ()
+  (should (= 9 (hamming-distance "GGACGGATTCTG" "AGGACGGATTCT"))))
+
+(ert-deftest disallow-first-strand-longer ()
+  (should-error (hamming-distance "AATG" "AAA")))
 
+(ert-deftest disallow-first-strand-longer ()
+  (should-error (hamming-distance "ATA" "AGTG")))
 
 (provide 'hamming-test)
 ;;; hamming-test.el ends here

data/tracks/elisp/exercises/hamming/hamming.el

@@ -4,9 +4,6 @@
 
 ;;; Code:
 
-(require 'cl)
-
-
 
 (provide 'hamming)
 ;;; hamming.el ends here

data/tracks/fsharp/exercises/custom-set/CustomSetTest.fs

@@ -1,229 +1,303 @@
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 module CustomSetTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open CustomSet
 
 [<Fact>]
 let ``Sets with no elements are empty`` () =
-    let actual = empty
-    isEmpty actual |> should equal true
+    let actual = CustomSet.isEmpty (CustomSet.fromList [])
+    actual |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sets with elements are not empty`` () =
-    let actual = singleton 1
-    isEmpty actual |> should equal false
+    let actual = CustomSet.isEmpty (CustomSet.fromList [1])
+    actual |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Nothing is contained in an empty set`` () =
-    let actual = empty
-    contains 1 actual |> should equal false
+    let setValue = CustomSet.fromList []
+    let element = 1
+    let actual = CustomSet.contains element setValue
+    actual |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Detect if the element is in the set`` () =
-    let actual = fromList [1; 2; 3]
-    contains 1 actual |> should equal true
+let ``When the element is in the set`` () =
+    let setValue = CustomSet.fromList [1; 2; 3]
+    let element = 1
+    let actual = CustomSet.contains element setValue
+    actual |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Detect if the element is not in the set`` () =
-    let actual = fromList [1; 2; 3]
-    contains 4 actual |> should equal false
-    
+let ``When the element is not in the set`` () =
+    let setValue = CustomSet.fromList [1; 2; 3]
+    let element = 4
+    let actual = CustomSet.contains element setValue
+    actual |> should equal false
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty set is a subset of another empty set`` () =
-    let left = empty
-    let right = empty
-    isSubsetOf left right |> should equal true
-    
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty set is a subset of non-empty set`` () =
-    let left = empty
-    let right = singleton 1
-    isSubsetOf left right |> should equal true
-    
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [1]
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is not a subset of empty set`` () =
-    let left = singleton 1
-    let right = empty
-    isSubsetOf left right |> should equal false
-    
+    let set1 = CustomSet.fromList [1]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal false
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Set is a subset of set with exact same elements`` () =
-    let left = fromList [1; 2; 3]
-    let right = fromList [1; 2; 3]
-    isSubsetOf left right |> should equal true
-    
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [1; 2; 3]
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Set is a subset of larger set with same elements`` () =
-    let left = fromList [1; 2; 3]
-    let right = fromList [4; 1; 2; 3]
-    isSubsetOf left right |> should equal true
-    
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [4; 1; 2; 3]
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Set is not a subset of set that does not contain its elements`` () =
-    let left = fromList [1; 2; 3]
-    let right = fromList [4; 1; 3]
-    isSubsetOf left right |> should equal false
-        
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [4; 1; 3]
+    let actual = CustomSet.isSubsetOf set1 set2
+    actual |> should equal false
+
 [<Fact(Skip = "Remove to run test")>]
 let ``The empty set is disjoint with itself`` () =
-    let left = empty
-    let right = empty
-    isDisjointFrom left right |> should equal true    
-    
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isDisjointFrom set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty set is disjoint with non-empty set`` () =
-    let left = empty
-    let right = singleton 1
-    isDisjointFrom left right |> should equal true
-    
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [1]
+    let actual = CustomSet.isDisjointFrom set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is disjoint with empty set`` () =
-    let left = singleton 1
-    let right = empty
-    isDisjointFrom left right |> should equal true
-    
+    let set1 = CustomSet.fromList [1]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isDisjointFrom set1 set2
+    actual |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Sets are not disjoint if they share an element`` () =
-    let left = fromList [1; 2]
-    let right = fromList [2; 3]    
-    isDisjointFrom left right |> should equal false
-    
+    let set1 = CustomSet.fromList [1; 2]
+    let set2 = CustomSet.fromList [2; 3]
+    let actual = CustomSet.isDisjointFrom set1 set2
+    actual |> should equal false
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Sets are disjoint if they share no elements`` () =
-    let left = fromList [1; 2]
-    let right = fromList [3; 4]
-    isDisjointFrom left right |> should equal true
+    let set1 = CustomSet.fromList [1; 2]
+    let set2 = CustomSet.fromList [3; 4]
+    let actual = CustomSet.isDisjointFrom set1 set2
+    actual |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty sets are equal`` () =
-    let left = empty
-    let right = empty
-    (left |> should equal right)
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty set is not equal to non-empty set`` () =
-    let left = empty
-    let right = fromList [1; 2; 3]
-    left |> should not' (equal right)
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [1; 2; 3]
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Non-empty set is not equal to empty set`` () =
-    let left = fromList [1; 2; 3]
-    let right = empty
-    left |> should not' (equal right)
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sets with the same elements are equal`` () =
-    let left = fromList [1; 2]
-    let right = fromList [2; 1]
-    (left |> should equal right)
+    let set1 = CustomSet.fromList [1; 2]
+    let set2 = CustomSet.fromList [2; 1]
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sets with different elements are not equal`` () =
-    let left = fromList [1; 2; 3]
-    let right = fromList [1; 2; 4]
-    left |> should not' (equal right)
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [1; 2; 4]
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal false
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Set is not equal to larger set with same elements`` () =
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [1; 2; 3; 4]
+    let actual = CustomSet.isEqualTo set1 set2
+    actual |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Add to empty set`` () =
-    let actual = empty |> insert 3
-    let expected = fromList [3]
-    actual |> should equal expected
+    let setValue = CustomSet.fromList []
+    let element = 3
+    let actual = CustomSet.insert element setValue
+    let expectedSet = CustomSet.fromList [3]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Add to non-empty set`` () =
-    let actual = fromList [1; 2; 4] |> insert 3
-    let expected = fromList [1; 2; 3; 4]
-    actual |> should equal expected
+    let setValue = CustomSet.fromList [1; 2; 4]
+    let element = 3
+    let actual = CustomSet.insert element setValue
+    let expectedSet = CustomSet.fromList [1; 2; 3; 4]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Adding an existing element does not change the set`` () =
-    let actual = fromList [1; 2; 3] |> insert 3
-    let expected = fromList [1; 2; 3]
-    actual |> should equal expected
-            
+    let setValue = CustomSet.fromList [1; 2; 3]
+    let element = 3
+    let actual = CustomSet.insert element setValue
+    let expectedSet = CustomSet.fromList [1; 2; 3]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two empty sets is an empty set`` () =
-    let left = empty
-    let right = empty
-    intersection left right |> isEmpty |> should equal true
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.intersection set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Intersection of an empty set and non-empty set is an empty set`` () =
-    let left = empty
-    let right = fromList [3; 2; 5]
-    intersection left right |> isEmpty |> should equal true
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [3; 2; 5]
+    let actual = CustomSet.intersection set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Intersection of a non-empty set and an empty set is an empty set`` () =
-    let left = fromList [1; 2; 3; 4]
-    let right = empty
-    intersection left right |> isEmpty |> should equal true
+    let set1 = CustomSet.fromList [1; 2; 3; 4]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.intersection set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two sets with no shared elements is an empty set`` () =
-    let left = fromList [1; 2; 3]
-    let right = fromList [4; 5; 6]
-    intersection left right |> isEmpty |> should equal true
+    let set1 = CustomSet.fromList [1; 2; 3]
+    let set2 = CustomSet.fromList [4; 5; 6]
+    let actual = CustomSet.intersection set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Intersection of two sets with shared elements is a set of the shared elements`` () =
-    let left = fromList [1; 2; 3; 4]
-    let right = fromList [3; 2; 5]
-    let expected = fromList [2; 3]
-    intersection left right |> should equal expected
-            
+    let set1 = CustomSet.fromList [1; 2; 3; 4]
+    let set2 = CustomSet.fromList [3; 2; 5]
+    let actual = CustomSet.intersection set1 set2
+    let expectedSet = CustomSet.fromList [2; 3]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Difference of two empty sets is an empty set`` () =
-    let left = empty
-    let right = empty
-    difference left right |> isEmpty |> should equal true
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.difference set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Difference of an empty set and non-empty set is an empty set`` () =
-    let left = empty
-    let right = fromList [3; 2; 5]
-    difference left right |> isEmpty |> should equal true
+let ``Difference of empty set and non-empty set is an empty set`` () =
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [3; 2; 5]
+    let actual = CustomSet.difference set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Difference of a non-empty set and an empty set is an empty set`` () =
-    let left = fromList [1; 2; 3; 4]
-    let right = empty
-    let expected = fromList [1; 2; 3; 4]
-    difference left right |> should equal expected
+let ``Difference of a non-empty set and an empty set is the non-empty set`` () =
+    let set1 = CustomSet.fromList [1; 2; 3; 4]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.difference set1 set2
+    let expectedSet = CustomSet.fromList [1; 2; 3; 4]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Difference of two non-empty sets is a set of elements that are only in the first set`` () =
-    let left = fromList [3; 2; 1]
-    let right = fromList [2; 4]
-    let expected = fromList [1; 3]
-    difference left right |> should equal expected
-           
+    let set1 = CustomSet.fromList [3; 2; 1]
+    let set2 = CustomSet.fromList [2; 4]
+    let actual = CustomSet.difference set1 set2
+    let expectedSet = CustomSet.fromList [1; 3]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Union of two empty sets is an empty set`` () =
-    let left = empty
-    let right = empty
-    union left right |> isEmpty |> should equal true
+let ``Union of empty sets is an empty set`` () =
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.union set1 set2
+    let expectedSet = CustomSet.fromList []
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Union of an empty set and non-empty set is the non-empty set`` () =
-    let left = empty
-    let right = fromList [2]
-    let expected = fromList [2]
-    union left right |> should equal expected
+    let set1 = CustomSet.fromList []
+    let set2 = CustomSet.fromList [2]
+    let actual = CustomSet.union set1 set2
+    let expectedSet = CustomSet.fromList [2]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Union of a non-empty set and empty set is the non-empty set`` () =
-    let left = fromList [1; 3]
-    let right = empty
-    let expected = fromList [1; 3]
-    union left right |> should equal expected
+    let set1 = CustomSet.fromList [1; 3]
+    let set2 = CustomSet.fromList []
+    let actual = CustomSet.union set1 set2
+    let expectedSet = CustomSet.fromList [1; 3]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Union of non-empty sets contains all unique elements`` () =
-    let left = fromList [1; 3]
-    let right = fromList [2; 3]
-    let expected = fromList [3; 2; 1]
-    union left right |> should equal expected
+    let set1 = CustomSet.fromList [1; 3]
+    let set2 = CustomSet.fromList [2; 3]
+    let actual = CustomSet.union set1 set2
+    let expectedSet = CustomSet.fromList [3; 2; 1]
+    let actualBool = CustomSet.isEqualTo actual expectedSet
+    actualBool |> should equal true
+