Test upgrades

exercises/practice/etl/.meta/testAnnotation.json

@@ -1,18 +1,18 @@
 [
   {
-    "name": "Single letter",
-    "test_code": "let  \n  lettersByScore = [(1, [?A])] |> Map.fromList\n  expected = [(?a, 1)] |> Map.fromList\n  Test.label.deprecated \"Single letter\" <| Test.expect (transform lettersByScore === expected)"
+    "name": "single letter",
+    "test_code": "verify do\n  labeled \"single letter\" do\n    expected = [(?a, 1)] |> Map.fromList\n    lettersByScore = [(1, [?A])] |> Map.fromList\n    actual = transform lettersByScore\n    label \"expected\" (expected |> Map.toList)\n    label \"actual\" (actual |> Map.toList)\n    ensureEqual expected actual"
   },
   {
-    "name": "Single score with multiple letters",
-    "test_code": "let\n  lettersByScore = [(1, [?A, ?E, ?I, ?O, ?U])] |> Map.fromList\n  expected = \n    [ (?a, 1),\n      (?e, 1),\n      (?i, 1),\n      (?o, 1),\n      (?u, 1) ] |> Map.fromList\n  Test.label.deprecated \"Single score with multiple letters\" <| Test.expect (transform lettersByScore === expected)"
+    "name": "single score with multiple letters",
+    "test_code": "verify do\n  labeled \"single score with multiple letters\" do\n    expected = \n      [ (?a, 1),\n        (?e, 1),\n        (?i, 1),\n        (?o, 1),\n        (?u, 1) ] |> Map.fromList\n    lettersByScore = [(1, [?A, ?E, ?I, ?O, ?U])] |> Map.fromList\n    actual = transform lettersByScore\n    label \"expected\" (expected |> Map.toList)\n    label \"actual\" (actual |> Map.toList)\n    ensureEqual expected actual"
   },
   {
-    "name": "Multiple scores with multiple letters",
-    "test_code": "let  \n  lettersByScore = \n    [ (1, [?A, ?E]),\n      (2, [?D, ?G]) ] |> Map.fromList\n  expected = \n    [ (?a, 1),\n      (?d, 2),\n      (?e, 1),\n      (?g, 2) ] |> Map.fromList\n  Test.label.deprecated \"Multiple scores with multiple letters\" <| Test.expect (transform lettersByScore === expected)"
+    "name": "multiple scores with multiple letters",
+    "test_code": "verify do\n  labeled \"multiple scores with multiple letters\" do\n    expected = \n      [ (?a, 1),\n        (?d, 2),\n        (?e, 1),\n        (?g, 2) ] |> Map.fromList\n    lettersByScore = \n      [ (1, [?A, ?E]),\n        (2, [?D, ?G]) ] |> Map.fromList\n    actual = transform lettersByScore\n    label \"expected\" (expected |> Map.toList)\n    label \"actual\" (actual |> Map.toList)\n    ensureEqual expected actual"
   },
   {
-    "name": "Multiple scores with differing numbers of letters",
-    "test_code": "let\n  lettersByScore = \n    [ (1, [?A, ?E, ?I, ?O, ?U, ?L, ?N, ?R, ?S, ?T]),\n      (2, [?D, ?G]),\n      (3, [?B, ?C, ?M, ?P]),\n      (4, [?F, ?H, ?V, ?W, ?Y]),\n      (5, [?K]),\n      (8, [?J, ?X]),\n      (10, [?Q, ?Z]) ] |> Map.fromList\n  expected = \n    [ (?a, 1),\n      (?b, 3),\n      (?c, 3),\n      (?d, 2),\n      (?e, 1),\n      (?f, 4),\n      (?g, 2),\n      (?h, 4),\n      (?i, 1),\n      (?j, 8),\n      (?k, 5),\n      (?l, 1),\n      (?m, 3),\n      (?n, 1),\n      (?o, 1),\n      (?p, 3),\n      (?q, 10),\n      (?r, 1),\n      (?s, 1),\n      (?t, 1),\n      (?u, 1),\n      (?v, 4),\n      (?w, 4),\n      (?x, 8),\n      (?y, 4),\n      (?z, 10) ] |> Map.fromList\n  Test.label.deprecated \"Multiple scores with differing numbers of letters\" <| Test.expect (transform lettersByScore == expected)"
+    "name": "multiple scores with differing numbers of letters",
+    "test_code": "verify do\n  labeled \"multiple scores with differing numbers of letters\" do\n    expected = \n      [ (?a, 1),\n        (?b, 3),\n        (?c, 3),\n        (?d, 2),\n        (?e, 1),\n        (?f, 4),\n        (?g, 2),\n        (?h, 4),\n        (?i, 1),\n        (?j, 8),\n        (?k, 5),\n        (?l, 1),\n        (?m, 3),\n        (?n, 1),\n        (?o, 1),\n        (?p, 3),\n        (?q, 10),\n        (?r, 1),\n        (?s, 1),\n        (?t, 1),\n        (?u, 1),\n        (?v, 4),\n        (?w, 4),\n        (?x, 8),\n        (?y, 4),\n        (?z, 10) ] |> Map.fromList\n    lettersByScore = \n      [ (1, [?A, ?E, ?I, ?O, ?U, ?L, ?N, ?R, ?S, ?T]),\n        (2, [?D, ?G]),\n        (3, [?B, ?C, ?M, ?P]),\n        (4, [?F, ?H, ?V, ?W, ?Y]),\n        (5, [?K]),\n        (8, [?J, ?X]),\n        (10, [?Q, ?Z]) ] |> Map.fromList\n    actual = transform lettersByScore\n    label \"expected\" (expected |> Map.toList)\n    label \"actual\" (actual |> Map.toList)\n    ensure (expected == actual)"
   }
-]
+]

exercises/practice/etl/etl.test.u

@@ -1,68 +1,90 @@
-etl.test.ex1 = let  
-  lettersByScore = [(1, [?A])] |> Map.fromList
-  expected = [(?a, 1)] |> Map.fromList
-  Test.label.deprecated "Single letter" <| Test.expect (transform lettersByScore === expected)
+etl.test.ex1 = verify do
+  labeled "single letter" do
+    expected = [(?a, 1)] |> Map.fromList
+    lettersByScore = [(1, [?A])] |> Map.fromList
+    actual = transform lettersByScore
+    label "expected" (expected |> Map.toList)
+    label "actual" (actual |> Map.toList)
+    ensureEqual expected actual
 
-etl.test.ex2 = let
-  lettersByScore = [(1, [?A, ?E, ?I, ?O, ?U])] |> Map.fromList
-  expected = 
-    [ (?a, 1),
-      (?e, 1),
-      (?i, 1),
-      (?o, 1),
-      (?u, 1) ] |> Map.fromList
-  Test.label.deprecated "Single score with multiple letters" <| Test.expect (transform lettersByScore === expected)
+etl.test.ex2 = verify do
+  labeled "single score with multiple letters" do
+    expected =
+      [ (?a, 1),
+        (?e, 1),
+        (?i, 1),
+        (?o, 1),
+        (?u, 1) ] |> Map.fromList
+    lettersByScore = [(1, [?A, ?E, ?I, ?O, ?U])] |> Map.fromList
+    actual = transform lettersByScore
+    label "expected" (expected |> Map.toList)
+    label "actual" (actual |> Map.toList)
+    ensureEqual expected actual
 
-etl.test.ex3 = let  
-  lettersByScore = 
-    [ (1, [?A, ?E]),
-      (2, [?D, ?G]) ] |> Map.fromList
-  expected = 
-    [ (?a, 1),
-      (?d, 2),
-      (?e, 1),
-      (?g, 2) ] |> Map.fromList
-  Test.label.deprecated "Multiple scores with multiple letters" <| Test.expect (transform lettersByScore === expected)
+etl.test.ex3 = verify do
+  labeled "multiple scores with multiple letters" do
+    expected =
+      [ (?a, 1),
+        (?d, 2),
+        (?e, 1),
+        (?g, 2) ] |> Map.fromList
+    lettersByScore =
+      [ (1, [?A, ?E]),
+        (2, [?D, ?G]) ] |> Map.fromList
+    actual = transform lettersByScore
+    label "expected" (expected |> Map.toList)
+    label "actual" (actual |> Map.toList)
+    ensureEqual expected actual
 
-etl.test.ex4 = let
-  lettersByScore = 
-    [ (1, [?A, ?E, ?I, ?O, ?U, ?L, ?N, ?R, ?S, ?T]),
-      (2, [?D, ?G]),
-      (3, [?B, ?C, ?M, ?P]),
-      (4, [?F, ?H, ?V, ?W, ?Y]),
-      (5, [?K]),
-      (8, [?J, ?X]),
-      (10, [?Q, ?Z]) ] |> Map.fromList
-  expected = 
-    [ (?a, 1),
-      (?b, 3),
-      (?c, 3),
-      (?d, 2),
-      (?e, 1),
-      (?f, 4),
-      (?g, 2),
-      (?h, 4),
-      (?i, 1),
-      (?j, 8),
-      (?k, 5),
-      (?l, 1),
-      (?m, 3),
-      (?n, 1),
-      (?o, 1),
-      (?p, 3),
-      (?q, 10),
-      (?r, 1),
-      (?s, 1),
-      (?t, 1),
-      (?u, 1),
-      (?v, 4),
-      (?w, 4),
-      (?x, 8),
-      (?y, 4),
-      (?z, 10) ] |> Map.fromList
-  Test.label.deprecated "Multiple scores with differing numbers of letters" <| Test.expect (transform lettersByScore == expected)
+etl.test.ex4 = verify do
+  use Map ==
 
-test> etl.tests = runAll [
+  labeled "multiple scores with differing numbers of letters" do
+    expected =
+      [ (?a, 1),
+        (?b, 3),
+        (?c, 3),
+        (?d, 2),
+        (?e, 1),
+        (?f, 4),
+        (?g, 2),
+        (?h, 4),
+        (?i, 1),
+        (?j, 8),
+        (?k, 5),
+        (?l, 1),
+        (?m, 3),
+        (?n, 1),
+        (?o, 1),
+        (?p, 3),
+        (?q, 10),
+        (?r, 1),
+        (?s, 1),
+        (?t, 1),
+        (?u, 1),
+        (?v, 4),
+        (?w, 4),
+        (?x, 8),
+        (?y, 4),
+        (?z, 10) ] |> Map.fromList
+    lettersByScore =
+      [ (1, [?A, ?E, ?I, ?O, ?U, ?L, ?N, ?R, ?S, ?T]),
+        (2, [?D, ?G]),
+        (3, [?B, ?C, ?M, ?P]),
+        (4, [?F, ?H, ?V, ?W, ?Y]),
+        (5, [?K]),
+        (8, [?J, ?X]),
+        (10, [?Q, ?Z]) ] |> Map.fromList
+    actual = transform lettersByScore
+    ensuringWith
+      "Mappings are not equal"
+      (
+        ("expected:", expected |> Map.toList),
+        ("actual:", actual |> Map.toList)
+      )
+      (_ -> expected == actual)
+
+test> etl.tests = join [
   etl.test.ex1,
   etl.test.ex2,
   etl.test.ex3,

exercises/practice/hello-world/.meta/testAnnotation.json

@@ -1,6 +1,6 @@
 [
   {
-    "name": "hello.test",
-    "test_code": "expected = \"Hello, World!\"\n  Test.expect (hello === expected)\ntest> hello.tests = runAll [hello.test]"
+    "name": "should return 'Hello, World!'",
+    "test_code": "verify do\n  labeled \"should return 'Hello, World!'\" do\n    expected = \"Hello, World!\"\n    actual = hello\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   }
-]
+]

exercises/practice/hello-world/hello.test.u

@@ -1,6 +1,9 @@
-use Universal
+hello.test = verify do
+  labeled "should return 'Hello, World!'" do
+    expected = "Hello, World!"
+    actual = hello
+    label "expected" expected
+    label "actual" actual
+    ensureEqual expected actual
 
-hello.test =
-  expected = "Hello, World!"
-  Test.expect (hello === expected)
-test> hello.tests = runAll [hello.test]
+test> hello.tests = hello.test

exercises/practice/isogram/.meta/testAnnotation.json

@@ -1,58 +1,58 @@
 [
   {
     "name": "Empty string",
-    "test_code": "let\n  Test.label.deprecated \"Empty string\" <| Test.expect (isIsogram \"\" === true)"
+    "test_code": "verify do\n  labeled \"Empty string\" do\n    expected = true\n    actual = isIsogram \"\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Isogram with only lower case characters",
-    "test_code": "let\n  Test.label.deprecated \"Isogram with only lower case characters\" <| Test.expect (isIsogram \"isogram\" === true)"
+    "test_code": "verify do\n  labeled \"Isogram with only lower case characters\" do\n    expected = true\n    actual = isIsogram \"isogram\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Word with one duplicated character",
-    "test_code": "let\n  Test.label.deprecated \"Word with one duplicated character\" <| Test.expect (isIsogram \"eleven\" === false)"
+    "test_code": "verify do\n  labeled \"Word with one duplicated character\" do\n    expected = false\n    actual = isIsogram \"eleven\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Word with one duplicated character from the end of the alphabet",
-    "test_code": "let\n  Test.label.deprecated \"Word with one duplicated character from the end of the alphabet\" <| Test.expect (isIsogram \"zzyzx\" === false)"
+    "test_code": "verify do\n  labeled \"Word with one duplicated character from the end of the alphabet\" do\n    expected = false\n    actual = isIsogram \"zzyzx\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Longest reported english isogram",
-    "test_code": "let\n  Test.label.deprecated \"Longest reported english isogram\" <| Test.expect (isIsogram \"subdermatoglyphic\" === true)"
+    "test_code": "verify do\n  labeled \"Longest reported english isogram\" do\n    expected = true\n    actual = isIsogram \"subdermatoglyphic\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Word with duplicated character in mixed case",
-    "test_code": "let\n  Test.label.deprecated \"Word with duplicated character in mixed case\" <| Test.expect (isIsogram \"Alphabet\" === false)"
+    "test_code": "verify do\n  labeled \"Word with duplicated character in mixed case\" do\n    expected = false\n    actual = isIsogram \"Alphabet\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Word with duplicated character in mixed case, lowercase first",
-    "test_code": "let\n  Test.label.deprecated \"Word with duplicated character in mixed case, lowercase first\" <| Test.expect (isIsogram \"alphAbet\" === false)"
+    "test_code": "verify do\n  labeled \"Word with duplicated character in mixed case, lowercase first\" do\n    expected = false\n    actual = isIsogram \"alphAbet\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Hypothetical isogrammic word with hyphen",
-    "test_code": "let\n  Test.label.deprecated \"Hypothetical isogrammic word with hyphen\" <| Test.expect (isIsogram \"thumbscrew-japingly\" === true)"
+    "test_code": "verify do\n  labeled \"Hypothetical isogrammic word with hyphen\" do\n    expected = true\n    actual = isIsogram \"thumbscrew-japingly\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Hypothetical word with duplicated character following hyphen",
-    "test_code": "let\n  Test.label.deprecated \"Hypothetical word with duplicated character following hyphen\" <| Test.expect (isIsogram \"thumbscrew-jappingly\" === false)"
+    "test_code": "verify do\n  labeled \"Hypothetical word with duplicated character following hyphen\" do\n    expected = false\n    actual = isIsogram \"thumbscrew-jappingly\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Isogram with duplicated hyphen",
-    "test_code": "let\n  Test.label.deprecated \"Isogram with duplicated hyphen\" <| Test.expect (isIsogram \"six-year-old\" === true)"
+    "test_code": "verify do\n  labeled \"Isogram with duplicated hyphen\" do\n    expected = true\n    actual = isIsogram \"six-year-old\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Made-up name that is an isogram",
-    "test_code": "let\n  Test.label.deprecated \"Made-up name that is an isogram\" <| Test.expect (isIsogram \"Emily Jung Schwartzkopf\" === true)"
+    "test_code": "verify do\n  labeled \"Made-up name that is an isogram\" do\n    expected = true\n    actual = isIsogram \"Emily Jung Schwartzkopf\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Duplicated character in the middle",
-    "test_code": "let\n  Test.label.deprecated \"Duplicated character in the middle\" <| Test.expect (isIsogram \"accentor\" === false)"
+    "test_code": "verify do\n  labeled \"Duplicated character in the middle\" do\n    expected = false\n    actual = isIsogram \"accentor\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Same first and last characters",
-    "test_code": "let\n  Test.label.deprecated \"Same first and last characters\" <| Test.expect (isIsogram \"angola\" === false)"
+    "test_code": "verify do\n  labeled \"Same first and last characters\" do\n    expected = false\n    actual = isIsogram \"angola\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   },
   {
     "name": "Word with duplicated character and with two hyphens",
-    "test_code": "let\n  Test.label.deprecated \"Word with duplicated character and with two hyphens\" <| Test.expect (isIsogram \"up-to-date\" === false)"
+    "test_code": "verify do\n  labeled \"Word with duplicated character and with two hyphens\" do\n    expected = false\n    actual = isIsogram \"up-to-date\"\n    label \"expected\" expected\n    label \"actual\" actual\n    ensureEqual expected actual"
   }
-]
+]