Merge tests into a larger file (part 5 of ∞) (#9368)

* merge magics

* merge metatype tests

* merge method tests

* merge objects tests

* change `import future` to `import sugar`

Nim in Action tests are left with `import future`, to ensure compatibility.

* merge overload tests

* merge proc tests

* merge procvar tests

* merge range tests

* merge seq tests

* merge sets tests

* remove wrong assert from `tsets3`

* fix `jsTests`

* better fix

tests/sets/tsetpop.nim

@@ -1,22 +0,0 @@
-discard """
-  targets: "c c++ js"
-  output: '''1000
-0
-set is empty
-'''
-"""
-
-import sets
-
-var a = initSet[int]()
-for i in 1..1000:
-  a.incl(i)
-echo len(a)
-for i in 1..1000:  
-  discard a.pop()
-echo len(a)
-
-try:
-  echo a.pop()
-except KeyError as e:
-  echo e.msg

tests/sets/tsets2.nim

@@ -1,71 +0,0 @@
-discard """
-  output: '''true'''
-"""
-
-import hashes, sets
-
-const
-  data = [
-    "34", "12",
-    "90", "0",
-    "1", "2",
-    "3", "4",
-    "5", "6",
-    "7", "8",
-    "9", "---00",
-    "10", "11", "19",
-    "20", "30", "40",
-    "50", "60", "70",
-    "80"]
-
-block tableTest1:
-  var t = initSet[tuple[x, y: int]]()
-  t.incl((0,0))
-  t.incl((1,0))
-  assert(not t.containsOrIncl((0,1)))
-  t.incl((1,1))
-
-  for x in 0..1:
-    for y in 0..1:
-      assert((x,y) in t)
-  #assert($t ==
-  #  "{(x: 0, y: 0), (x: 0, y: 1), (x: 1, y: 0), (x: 1, y: 1)}")
-
-block setTest2:
-  var t = initSet[string]()
-  t.incl("test")
-  t.incl("111")
-  t.incl("123")
-  t.excl("111")
-  t.incl("012")
-  t.incl("123") # test duplicates
-
-  assert "123" in t
-  assert "111" notin t # deleted
-
-  assert t.missingOrExcl("000") == true
-  assert "000" notin t
-  assert t.missingOrExcl("012") == false
-  assert "012" notin t
-
-  assert t.containsOrIncl("012") == false 
-  assert t.containsOrIncl("012") == true
-  assert "012" in t # added back 
-
-  for key in items(data): t.incl(key)
-  for key in items(data): assert key in t
-
-  for key in items(data): t.excl(key)
-  for key in items(data): assert key notin t
-
-block orderedSetTest1:
-  var t = data.toOrderedSet
-  for key in items(data): assert key in t
-  var i = 0
-  # `items` needs to yield in insertion order:
-  for key in items(t):
-    assert key == data[i]
-    inc(i)
-
-echo "true"
-

tests/sets/tsets3.nim

@@ -1,100 +0,0 @@
-include sets
-
-let
-  s1: TSet[int] = toSet([1, 2, 4, 8, 16])
-  s2: TSet[int] = toSet([1, 2, 3, 5, 8])
-  s3: TSet[int] = toSet([3, 5, 7])
-
-block union:
-  let
-    s1_s2 = union(s1, s2)
-    s1_s3 = s1 + s3
-    s2_s3 = s2 + s3
-
-  assert s1_s2.len == 7
-  assert s1_s3.len == 8
-  assert s2_s3.len == 6
-
-  for i in s1:
-    assert i in s1_s2
-    assert i in s1_s3
-  for i in s2:
-    assert i in s1_s2
-    assert i in s2_s3
-  for i in s3:
-    assert i in s1_s3
-    assert i in s2_s3
-
-  assert((s1 + s1) == s1)
-  assert((s2 + s1) == s1_s2)
-
-block intersection:
-  let
-    s1_s2 = intersection(s1, s2)
-    s1_s3 = intersection(s1, s3)
-    s2_s3 = s2 * s3
-
-  assert s1_s2.len == 3
-  assert s1_s3.len == 0
-  assert s2_s3.len == 2
-
-  for i in s1_s2:
-    assert i in s1
-    assert i in s2
-  for i in s1_s3:
-    assert i in s1
-    assert i in s3
-  for i in s2_s3:
-    assert i in s2
-    assert i in s3
-
-  assert((s2 * s2) == s2)
-  assert((s3 * s2) == s2_s3)
-
-block symmetricDifference:
-  let
-    s1_s2 = symmetricDifference(s1, s2)
-    s1_s3 = s1 -+- s3
-    s2_s3 = s2 -+- s3
-
-  assert s1_s2.len == 4
-  assert s1_s3.len == 8
-  assert s2_s3.len == 4
-
-  for i in s1:
-    assert i in s1_s2 xor i in s2
-    assert i in s1_s3 xor i in s3
-  for i in s2:
-    assert i in s1_s2 xor i in s1
-    assert i in s2_s3 xor i in s3
-  for i in s3:
-    assert i in s1_s3 xor i in s1
-    assert i in s2_s3 xor i in s2
-
-  assert((s3 -+- s3) == initSet[int]())
-  assert((s3 -+- s1) == s1_s3)
-
-block difference:
-  let
-    s1_s2 = difference(s1, s2)
-    s1_s3 = difference(s1, s3)
-    s2_s3 = s2 - s3
-
-  assert s1_s2.len == 2
-  assert s1_s3.len == 5
-  assert s2_s3.len == 3
-
-  for i in s1:
-    assert i in s1_s2 xor i in s2
-    assert i in s1_s3 xor i in s3
-  for i in s2:
-    assert i in s2_s3 xor i in s3
-
-  assert((s2 - s2) == initSet[int]())
-  assert((s1 - s3 - s1) == s1 -+- s3)
-
-block disjoint:
-  assert(not disjoint(s1, s2))
-  assert disjoint(s1, s3)
-  assert(not disjoint(s2, s3))
-  assert(not disjoint(s2, s2))

tests/sets/tsets_lt.nim

@@ -1,12 +0,0 @@
-discard """
-  output: '''true
-true
-true'''
-"""
-
-var s, s1: set[char]
-s = {'a'..'d'}
-s1 = {'a'..'c'}
-echo s1 < s
-echo s1 * s == {'a'..'c'}
-echo s1 <= s

tests/sets/tvarious.nim

@@ -0,0 +1,200 @@
+discard """
+  output: '''
+set is empty
+'''
+"""
+
+
+import sets, hashes
+
+
+block tsetpop:
+  var a = initSet[int]()
+  for i in 1..1000:
+    a.incl(i)
+  doAssert len(a) == 1000
+  for i in 1..1000:
+    discard a.pop()
+  doAssert len(a) == 0
+
+  try:
+    echo a.pop()
+  except KeyError as e:
+    echo e.msg
+
+
+
+block tsets_lt:
+  var s, s1: set[char]
+  s = {'a'..'d'}
+  s1 = {'a'..'c'}
+  doAssert s1 < s
+  doAssert s1 * s == {'a'..'c'}
+  doAssert s1 <= s
+
+
+
+block tsets2:
+  const
+    data = [
+      "34", "12",
+      "90", "0",
+      "1", "2",
+      "3", "4",
+      "5", "6",
+      "7", "8",
+      "9", "---00",
+      "10", "11", "19",
+      "20", "30", "40",
+      "50", "60", "70",
+      "80"]
+
+  block tableTest1:
+    var t = initSet[tuple[x, y: int]]()
+    t.incl((0,0))
+    t.incl((1,0))
+    assert(not t.containsOrIncl((0,1)))
+    t.incl((1,1))
+
+    for x in 0..1:
+      for y in 0..1:
+        assert((x,y) in t)
+    #assert($t ==
+    #  "{(x: 0, y: 0), (x: 0, y: 1), (x: 1, y: 0), (x: 1, y: 1)}")
+
+  block setTest2:
+    var t = initSet[string]()
+    t.incl("test")
+    t.incl("111")
+    t.incl("123")
+    t.excl("111")
+    t.incl("012")
+    t.incl("123") # test duplicates
+
+    assert "123" in t
+    assert "111" notin t # deleted
+
+    assert t.missingOrExcl("000")
+    assert "000" notin t
+    assert t.missingOrExcl("012") == false
+    assert "012" notin t
+
+    assert t.containsOrIncl("012") == false
+    assert t.containsOrIncl("012")
+    assert "012" in t # added back
+
+    for key in items(data): t.incl(key)
+    for key in items(data): assert key in t
+
+    for key in items(data): t.excl(key)
+    for key in items(data): assert key notin t
+
+  block orderedSetTest1:
+    var t = data.toOrderedSet
+    for key in items(data): assert key in t
+    var i = 0
+    # `items` needs to yield in insertion order:
+    for key in items(t):
+      assert key == data[i]
+      inc(i)
+
+
+
+block tsets3:
+  let
+    s1: TSet[int] = toSet([1, 2, 4, 8, 16])
+    s2: TSet[int] = toSet([1, 2, 3, 5, 8])
+    s3: TSet[int] = toSet([3, 5, 7])
+
+  block union:
+    let
+      s1_s2 = union(s1, s2)
+      s1_s3 = s1 + s3
+      s2_s3 = s2 + s3
+
+    assert s1_s2.len == 7
+    assert s1_s3.len == 8
+    assert s2_s3.len == 6
+
+    for i in s1:
+      assert i in s1_s2
+      assert i in s1_s3
+    for i in s2:
+      assert i in s1_s2
+      assert i in s2_s3
+    for i in s3:
+      assert i in s1_s3
+      assert i in s2_s3
+
+    assert((s1 + s1) == s1)
+    assert((s2 + s1) == s1_s2)
+
+  block intersection:
+    let
+      s1_s2 = intersection(s1, s2)
+      s1_s3 = intersection(s1, s3)
+      s2_s3 = s2 * s3
+
+    assert s1_s2.len == 3
+    assert s1_s3.len == 0
+    assert s2_s3.len == 2
+
+    for i in s1_s2:
+      assert i in s1
+      assert i in s2
+    for i in s1_s3:
+      assert i in s1
+      assert i in s3
+    for i in s2_s3:
+      assert i in s2
+      assert i in s3
+
+    assert((s2 * s2) == s2)
+    assert((s3 * s2) == s2_s3)
+
+  block symmetricDifference:
+    let
+      s1_s2 = symmetricDifference(s1, s2)
+      s1_s3 = s1 -+- s3
+      s2_s3 = s2 -+- s3
+
+    assert s1_s2.len == 4
+    assert s1_s3.len == 8
+    assert s2_s3.len == 4
+
+    for i in s1:
+      assert i in s1_s2 xor i in s2
+      assert i in s1_s3 xor i in s3
+    for i in s2:
+      assert i in s1_s2 xor i in s1
+      assert i in s2_s3 xor i in s3
+    for i in s3:
+      assert i in s1_s3 xor i in s1
+      assert i in s2_s3 xor i in s2
+
+    assert((s3 -+- s3) == initSet[int]())
+    assert((s3 -+- s1) == s1_s3)
+
+  block difference:
+    let
+      s1_s2 = difference(s1, s2)
+      s1_s3 = difference(s1, s3)
+      s2_s3 = s2 - s3
+
+    assert s1_s2.len == 2
+    assert s1_s3.len == 5
+    assert s2_s3.len == 3
+
+    for i in s1:
+      assert i in s1_s2 xor i in s2
+      assert i in s1_s3 xor i in s3
+    for i in s2:
+      assert i in s2_s3 xor i in s3
+
+    assert((s2 - s2) == initSet[int]())
+
+  block disjoint:
+    assert(not disjoint(s1, s2))
+    assert disjoint(s1, s3)
+    assert(not disjoint(s2, s3))
+    assert(not disjoint(s2, s2))