use doAssert in tests (#16486)
This commit is contained in:
flywind
GitHub
parent
f9a15dbae9
commit
6d442a40a6
78 changed files with 1056 additions and 1056 deletions
|
|
@ -24,7 +24,7 @@ block tseq2:
|
|||
# multiply two int sequences:
|
||||
for i in 0..len(a)-1: result[i] = a[i] * b[i]
|
||||
|
||||
assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])
|
||||
doAssert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -50,20 +50,20 @@ block thashes:
|
|||
var t = initTable[int,int]()
|
||||
t[0] = 42
|
||||
t[1] = t[0] + 1
|
||||
assert(t[0] == 42)
|
||||
assert(t[1] == 43)
|
||||
doAssert(t[0] == 42)
|
||||
doAssert(t[1] == 43)
|
||||
let t2 = {1: 1, 2: 2}.toTable
|
||||
assert(t2[2] == 2)
|
||||
doAssert(t2[2] == 2)
|
||||
|
||||
# Test with char
|
||||
block:
|
||||
var t = initTable[char,int]()
|
||||
t['0'] = 42
|
||||
t['1'] = t['0'] + 1
|
||||
assert(t['0'] == 42)
|
||||
assert(t['1'] == 43)
|
||||
doAssert(t['0'] == 42)
|
||||
doAssert(t['1'] == 43)
|
||||
let t2 = {'1': 1, '2': 2}.toTable
|
||||
assert(t2['2'] == 2)
|
||||
doAssert(t2['2'] == 2)
|
||||
|
||||
# Test with enum
|
||||
block:
|
||||
|
|
@ -72,10 +72,10 @@ block thashes:
|
|||
var t = initTable[E,int]()
|
||||
t[eA] = 42
|
||||
t[eB] = t[eA] + 1
|
||||
assert(t[eA] == 42)
|
||||
assert(t[eB] == 43)
|
||||
doAssert(t[eA] == 42)
|
||||
doAssert(t[eB] == 43)
|
||||
let t2 = {eA: 1, eB: 2}.toTable
|
||||
assert(t2[eB] == 2)
|
||||
doAssert(t2[eB] == 2)
|
||||
|
||||
# Test with range
|
||||
block:
|
||||
|
|
@ -84,10 +84,10 @@ block thashes:
|
|||
var t = initTable[R,int]() # causes warning, why?
|
||||
t[1] = 42 # causes warning, why?
|
||||
t[2] = t[1] + 1
|
||||
assert(t[1] == 42)
|
||||
assert(t[2] == 43)
|
||||
doAssert(t[1] == 42)
|
||||
doAssert(t[2] == 43)
|
||||
let t2 = {1.R: 1, 2.R: 2}.toTable
|
||||
assert(t2[2.R] == 2)
|
||||
doAssert(t2[2.R] == 2)
|
||||
|
||||
# Test which combines the generics for tuples + ordinals
|
||||
block:
|
||||
|
|
@ -96,10 +96,10 @@ block thashes:
|
|||
var t = initTable[(string, E, int, char), int]()
|
||||
t[("a", eA, 0, '0')] = 42
|
||||
t[("b", eB, 1, '1')] = t[("a", eA, 0, '0')] + 1
|
||||
assert(t[("a", eA, 0, '0')] == 42)
|
||||
assert(t[("b", eB, 1, '1')] == 43)
|
||||
doAssert(t[("a", eA, 0, '0')] == 42)
|
||||
doAssert(t[("b", eB, 1, '1')] == 43)
|
||||
let t2 = {("a", eA, 0, '0'): 1, ("b", eB, 1, '1'): 2}.toTable
|
||||
assert(t2[("b", eB, 1, '1')] == 2)
|
||||
doAssert(t2[("b", eB, 1, '1')] == 2)
|
||||
|
||||
# Test to check if overloading is possible
|
||||
# Unfortunately, this does not seem to work for int
|
||||
|
|
@ -165,9 +165,9 @@ block tableconstr:
|
|||
ignoreExpr({2: 3, "key": "value"})
|
||||
|
||||
# NEW:
|
||||
assert 56 in 50..100
|
||||
doAssert 56 in 50..100
|
||||
|
||||
assert 56 in ..60
|
||||
doAssert 56 in ..60
|
||||
|
||||
|
||||
block ttables2:
|
||||
|
|
@ -239,8 +239,8 @@ block tablesref:
|
|||
t[(1,1)] = "11"
|
||||
for x in 0..1:
|
||||
for y in 0..1:
|
||||
assert t[(x,y)] == $x & $y
|
||||
assert t.sortedPairs ==
|
||||
doAssert t[(x,y)] == $x & $y
|
||||
doAssert t.sortedPairs ==
|
||||
@[((x: 0, y: 0), "00"), ((x: 0, y: 1), "01"), ((x: 1, y: 0), "10"), ((x: 1, y: 1), "11")]
|
||||
|
||||
block tableTest2:
|
||||
|
|
@ -253,31 +253,31 @@ block tablesref:
|
|||
t["012"] = 67.9
|
||||
t["123"] = 1.5 # test overwriting
|
||||
|
||||
assert t["123"] == 1.5
|
||||
doAssert t["123"] == 1.5
|
||||
try:
|
||||
echo t["111"] # deleted
|
||||
except KeyError:
|
||||
discard
|
||||
assert(not hasKey(t, "111"))
|
||||
assert "111" notin t
|
||||
doAssert(not hasKey(t, "111"))
|
||||
doAssert "111" notin t
|
||||
|
||||
for key, val in items(data): t[key] = val.toFloat
|
||||
for key, val in items(data): assert t[key] == val.toFloat
|
||||
for key, val in items(data): doAssert t[key] == val.toFloat
|
||||
|
||||
|
||||
block orderedTableTest1:
|
||||
var t = newOrderedTable[string, int](2)
|
||||
for key, val in items(data): t[key] = val
|
||||
for key, val in items(data): assert t[key] == val
|
||||
for key, val in items(data): doAssert t[key] == val
|
||||
var i = 0
|
||||
# `pairs` needs to yield in insertion order:
|
||||
for key, val in pairs(t):
|
||||
assert key == data[i][0]
|
||||
assert val == data[i][1]
|
||||
doAssert key == data[i][0]
|
||||
doAssert val == data[i][1]
|
||||
inc(i)
|
||||
|
||||
for key, val in mpairs(t): val = 99
|
||||
for val in mvalues(t): assert val == 99
|
||||
for val in mvalues(t): doAssert val == 99
|
||||
|
||||
block countTableTest1:
|
||||
var s = data.toTable
|
||||
|
|
@ -286,11 +286,11 @@ block tablesref:
|
|||
for x in [t, r]:
|
||||
for k in s.keys:
|
||||
x.inc(k)
|
||||
assert x[k] == 1
|
||||
doAssert x[k] == 1
|
||||
x.inc("90", 3)
|
||||
x.inc("12", 2)
|
||||
x.inc("34", 1)
|
||||
assert t.largest()[0] == "90"
|
||||
doAssert t.largest()[0] == "90"
|
||||
|
||||
t.sort()
|
||||
r.sort(SortOrder.Ascending)
|
||||
|
|
@ -301,9 +301,9 @@ block tablesref:
|
|||
var i = 0
|
||||
for (k, v) in ps:
|
||||
case i
|
||||
of 0: assert k == "90" and v == 4
|
||||
of 1: assert k == "12" and v == 3
|
||||
of 2: assert k == "34" and v == 2
|
||||
of 0: doAssert k == "90" and v == 4
|
||||
of 1: doAssert k == "12" and v == 3
|
||||
of 2: doAssert k == "34" and v == 2
|
||||
else: break
|
||||
inc i
|
||||
|
||||
|
|
@ -327,17 +327,17 @@ block tablesref:
|
|||
|
||||
block nilTest:
|
||||
var i, j: TableRef[int, int] = nil
|
||||
assert i == j
|
||||
doAssert i == j
|
||||
j = newTable[int, int]()
|
||||
assert i != j
|
||||
assert j != i
|
||||
doAssert i != j
|
||||
doAssert j != i
|
||||
i = newTable[int, int]()
|
||||
assert i == j
|
||||
doAssert i == j
|
||||
|
||||
proc orderedTableSortTest() =
|
||||
var t = newOrderedTable[string, int](2)
|
||||
for key, val in items(data): t[key] = val
|
||||
for key, val in items(data): assert t[key] == val
|
||||
for key, val in items(data): doAssert t[key] == val
|
||||
proc cmper(x, y: tuple[key: string, val: int]): int = cmp(x.key, y.key)
|
||||
t.sort(cmper)
|
||||
var i = 0
|
||||
|
|
@ -369,25 +369,25 @@ block tablesref:
|
|||
t["test"] = 1.2345
|
||||
t["111"] = 1.000043
|
||||
t["123"] = 1.23
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
block clearOrderedTableTest:
|
||||
var t = newOrderedTable[string, int](2)
|
||||
for key, val in items(data): t[key] = val
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
block clearCountTableTest:
|
||||
var t = newCountTable[string]()
|
||||
t.inc("90", 3)
|
||||
t.inc("12", 2)
|
||||
t.inc("34", 1)
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
orderedTableSortTest()
|
||||
echo "3"
|
||||
|
|
@ -415,7 +415,7 @@ block: # https://github.com/nim-lang/Nim/issues/13496
|
|||
doAssert sortedPairs(t) == @[(15, 1), (17, 3), (19, 2)]
|
||||
var s = newSeq[int]()
|
||||
for v in t.values: s.add(v)
|
||||
assert s.len == 3
|
||||
doAssert s.len == 3
|
||||
doAssert sortedItems(s) == @[1, 2, 3]
|
||||
when t is OrderedTable|OrderedTableRef:
|
||||
doAssert toSeq(t.keys) == @[15, 19, 17]
|
||||
|
|
@ -433,14 +433,14 @@ block: # https://github.com/nim-lang/Nim/issues/13496
|
|||
block testNonPowerOf2:
|
||||
var a = initTable[int, int](7)
|
||||
a[1] = 10
|
||||
assert a[1] == 10
|
||||
doAssert a[1] == 10
|
||||
|
||||
var b = initTable[int, int](9)
|
||||
b[1] = 10
|
||||
assert b[1] == 10
|
||||
doAssert b[1] == 10
|
||||
|
||||
block emptyOrdered:
|
||||
var t1: OrderedTable[int, string]
|
||||
var t2: OrderedTable[int, string]
|
||||
assert t1 == t2
|
||||
doAssert t1 == t2
|
||||
|
||||
|
|
|
|||
|
|
@ -48,8 +48,8 @@ block tableTest1:
|
|||
t[(1,1)] = "11"
|
||||
for x in 0..1:
|
||||
for y in 0..1:
|
||||
assert t[(x,y)] == $x & $y
|
||||
assert t.sortedPairs == @[((x: 0, y: 0), "00"), ((x: 0, y: 1), "01"), ((x: 1, y: 0), "10"), ((x: 1, y: 1), "11")]
|
||||
doAssert t[(x,y)] == $x & $y
|
||||
doAssert t.sortedPairs == @[((x: 0, y: 0), "00"), ((x: 0, y: 1), "01"), ((x: 1, y: 0), "10"), ((x: 1, y: 1), "11")]
|
||||
|
||||
block tableTest2:
|
||||
var t = initTable[string, float]()
|
||||
|
|
@ -61,74 +61,74 @@ block tableTest2:
|
|||
t["012"] = 67.9
|
||||
t["123"] = 1.5 # test overwriting
|
||||
|
||||
assert t["123"] == 1.5
|
||||
doAssert t["123"] == 1.5
|
||||
try:
|
||||
echo t["111"] # deleted
|
||||
except KeyError:
|
||||
discard
|
||||
assert(not hasKey(t, "111"))
|
||||
doAssert(not hasKey(t, "111"))
|
||||
|
||||
assert "123" in t
|
||||
assert("111" notin t)
|
||||
doAssert "123" in t
|
||||
doAssert("111" notin t)
|
||||
|
||||
for key, val in items(data): t[key] = val.toFloat
|
||||
for key, val in items(data): assert t[key] == val.toFloat
|
||||
for key, val in items(data): doAssert t[key] == val.toFloat
|
||||
|
||||
assert(not t.hasKeyOrPut("456", 4.0)) # test absent key
|
||||
assert t.hasKeyOrPut("012", 3.0) # test present key
|
||||
doAssert(not t.hasKeyOrPut("456", 4.0)) # test absent key
|
||||
doAssert t.hasKeyOrPut("012", 3.0) # test present key
|
||||
var x = t.mgetOrPut("111", 1.5) # test absent key
|
||||
x = x * 2
|
||||
assert x == 3.0
|
||||
doAssert x == 3.0
|
||||
x = t.mgetOrPut("test", 1.5) # test present key
|
||||
x = x * 2
|
||||
assert x == 2 * 1.2345
|
||||
doAssert x == 2 * 1.2345
|
||||
|
||||
block orderedTableTest1:
|
||||
var t = initOrderedTable[string, int](2)
|
||||
for key, val in items(data): t[key] = val
|
||||
for key, val in items(data): assert t[key] == val
|
||||
for key, val in items(data): doAssert t[key] == val
|
||||
var i = 0
|
||||
# `pairs` needs to yield in insertion order:
|
||||
for key, val in pairs(t):
|
||||
assert key == data[i][0]
|
||||
assert val == data[i][1]
|
||||
doAssert key == data[i][0]
|
||||
doAssert val == data[i][1]
|
||||
inc(i)
|
||||
|
||||
for key, val in mpairs(t): val = 99
|
||||
for val in mvalues(t): assert val == 99
|
||||
for val in mvalues(t): doAssert val == 99
|
||||
|
||||
block orderedTableTest2:
|
||||
var
|
||||
s = initOrderedTable[string, int]()
|
||||
t = initOrderedTable[string, int]()
|
||||
assert s == t
|
||||
doAssert s == t
|
||||
for key, val in items(data): t[key] = val
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
for key, val in items(sorteddata): s[key] = val
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
t.clear()
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
for key, val in items(sorteddata): t[key] = val
|
||||
assert s == t
|
||||
doAssert s == t
|
||||
|
||||
block countTableTest1:
|
||||
var s = data.toTable
|
||||
var t = initCountTable[string]()
|
||||
|
||||
for k in s.keys: t.inc(k)
|
||||
for k in t.keys: assert t[k] == 1
|
||||
for k in t.keys: doAssert t[k] == 1
|
||||
t.inc("90", 3)
|
||||
t.inc("12", 2)
|
||||
t.inc("34", 1)
|
||||
assert t.largest()[0] == "90"
|
||||
doAssert t.largest()[0] == "90"
|
||||
|
||||
t.sort()
|
||||
var i = 0
|
||||
for k, v in t.pairs:
|
||||
case i
|
||||
of 0: assert k == "90" and v == 4
|
||||
of 1: assert k == "12" and v == 3
|
||||
of 2: assert k == "34" and v == 2
|
||||
of 0: doAssert k == "90" and v == 4
|
||||
of 1: doAssert k == "12" and v == 3
|
||||
of 2: doAssert k == "34" and v == 2
|
||||
else: break
|
||||
inc i
|
||||
|
||||
|
|
@ -136,19 +136,19 @@ block countTableTest2:
|
|||
var
|
||||
s = initCountTable[int]()
|
||||
t = initCountTable[int]()
|
||||
assert s == t
|
||||
doAssert s == t
|
||||
s.inc(1)
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
t.inc(2)
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
t.inc(1)
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
s.inc(2)
|
||||
assert s == t
|
||||
doAssert s == t
|
||||
s.inc(1)
|
||||
assert s != t
|
||||
doAssert s != t
|
||||
t.inc(1)
|
||||
assert s == t
|
||||
doAssert s == t
|
||||
|
||||
block mpairsTableTest1:
|
||||
var t = initTable[string, int]()
|
||||
|
|
@ -162,9 +162,9 @@ block mpairsTableTest1:
|
|||
|
||||
for k, v in t.pairs:
|
||||
if k == "a" or k == "c":
|
||||
assert v == 9
|
||||
doAssert v == 9
|
||||
else:
|
||||
assert v != 1 and v != 3
|
||||
doAssert v != 1 and v != 3
|
||||
|
||||
block SyntaxTest:
|
||||
var x = toTable[int, string]({:})
|
||||
|
|
@ -174,10 +174,10 @@ block zeroHashKeysTest:
|
|||
let initialLen = t.len
|
||||
var testTable = t
|
||||
testTable[nullHashKey] = value
|
||||
assert testTable[nullHashKey] == value
|
||||
assert testTable.len == initialLen + 1
|
||||
doAssert testTable[nullHashKey] == value
|
||||
doAssert testTable.len == initialLen + 1
|
||||
testTable.del(nullHashKey)
|
||||
assert testTable.len == initialLen
|
||||
doAssert testTable.len == initialLen
|
||||
|
||||
# with empty table
|
||||
doZeroHashValueTest(toTable[int,int]({:}), 0, 42)
|
||||
|
|
@ -194,46 +194,46 @@ block zeroHashKeysTest:
|
|||
|
||||
block clearTableTest:
|
||||
var t = data.toTable
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
block clearOrderedTableTest:
|
||||
var t = data.toOrderedTable
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
block clearCountTableTest:
|
||||
var t = initCountTable[string]()
|
||||
t.inc("90", 3)
|
||||
t.inc("12", 2)
|
||||
t.inc("34", 1)
|
||||
assert t.len() != 0
|
||||
doAssert t.len() != 0
|
||||
t.clear()
|
||||
assert t.len() == 0
|
||||
doAssert t.len() == 0
|
||||
|
||||
block withKeyTest:
|
||||
var t: SharedTable[int, int]
|
||||
t.init()
|
||||
t.withKey(1) do (k: int, v: var int, pairExists: var bool):
|
||||
assert(v == 0)
|
||||
doAssert(v == 0)
|
||||
pairExists = true
|
||||
v = 42
|
||||
assert(t.mget(1) == 42)
|
||||
doAssert(t.mget(1) == 42)
|
||||
t.withKey(1) do (k: int, v: var int, pairExists: var bool):
|
||||
assert(v == 42)
|
||||
doAssert(v == 42)
|
||||
pairExists = false
|
||||
try:
|
||||
discard t.mget(1)
|
||||
assert(false, "KeyError expected")
|
||||
doAssert(false, "KeyError expected")
|
||||
except KeyError:
|
||||
discard
|
||||
t.withKey(2) do (k: int, v: var int, pairExists: var bool):
|
||||
pairExists = false
|
||||
try:
|
||||
discard t.mget(2)
|
||||
assert(false, "KeyError expected")
|
||||
doAssert(false, "KeyError expected")
|
||||
except KeyError:
|
||||
discard
|
||||
|
||||
|
|
@ -242,20 +242,20 @@ block takeTest:
|
|||
t["key"] = 123
|
||||
|
||||
var val = 0
|
||||
assert(t.take("key", val))
|
||||
assert(val == 123)
|
||||
doAssert(t.take("key", val))
|
||||
doAssert(val == 123)
|
||||
|
||||
val = -1
|
||||
assert(not t.take("key", val))
|
||||
assert(val == -1)
|
||||
doAssert(not t.take("key", val))
|
||||
doAssert(val == -1)
|
||||
|
||||
assert(not t.take("otherkey", val))
|
||||
assert(val == -1)
|
||||
doAssert(not t.take("otherkey", val))
|
||||
doAssert(val == -1)
|
||||
|
||||
proc orderedTableSortTest() =
|
||||
var t = initOrderedTable[string, int](2)
|
||||
for key, val in items(data): t[key] = val
|
||||
for key, val in items(data): assert t[key] == val
|
||||
for key, val in items(data): doAssert t[key] == val
|
||||
t.sort(proc (x, y: tuple[key: string, val: int]): int = cmp(x.key, y.key))
|
||||
var i = 0
|
||||
# `pairs` needs to yield in sorted order:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue