mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-04-23 07:45:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

use doAssert in tests (#16486)

Browse Source
This commit is contained in:
flywind
2020-12-28 07:13:21 -06:00
committed by GitHub
parent f9a15dbae9
commit 6d442a40a6
78 changed files with 1056 additions and 1056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
tests/stdlib/tsequtils.nim
View File

@@ -15,7 +15,7 @@ block: # concat test
s2 = @[4, 5]
s3 = @[6, 7]
total = concat(s1, s2, s3)
assert total == @[1, 2, 3, 4, 5, 6, 7]
doAssert total == @[1, 2, 3, 4, 5, 6, 7]
block: # count test
let
@@ -35,18 +35,18 @@ block: # count test
ar3 = count(a2, 'y')
ar4 = count(a2, 'x')
ar5 = count(a2, 'a')
assert r0 == 0
assert r1 == 1
assert r2 == 2
assert r3 == 0
assert r4 == 1
assert r5 == 2
assert ar0 == 0
assert ar1 == 1
assert ar2 == 2
assert ar3 == 0
assert ar4 == 1
assert ar5 == 2
doAssert r0 == 0
doAssert r1 == 1
doAssert r2 == 2
doAssert r3 == 0
doAssert r4 == 1
doAssert r5 == 2
doAssert ar0 == 0
doAssert ar1 == 1
doAssert ar2 == 2
doAssert ar3 == 0
doAssert ar4 == 1
doAssert ar5 == 2
block: # cycle tests
let
@@ -62,9 +62,9 @@ block: # cycle tests
doAssert c.cycle(0) == @[]
block: # repeat tests
assert repeat(10, 5) == @[10, 10, 10, 10, 10]
assert repeat(@[1, 2, 3], 2) == @[@[1, 2, 3], @[1, 2, 3]]
assert repeat([1, 2, 3], 2) == @[[1, 2, 3], [1, 2, 3]]
doAssert repeat(10, 5) == @[10, 10, 10, 10, 10]
doAssert repeat(@[1, 2, 3], 2) == @[@[1, 2, 3], @[1, 2, 3]]
doAssert repeat([1, 2, 3], 2) == @[[1, 2, 3], [1, 2, 3]]
block: # deduplicates test
let
@@ -80,14 +80,14 @@ block: # deduplicates test
unique6 = deduplicate(dup2, true)
unique7 = deduplicate(dup3.sorted, true)
unique8 = deduplicate(dup4, true)
assert unique1 == @[1, 3, 4, 2, 8]
assert unique2 == @["a", "c", "d"]
assert unique3 == @[1, 3, 4, 2, 8]
assert unique4 == @["a", "c", "d"]
assert unique5 == @[1, 2, 3, 4, 8]
assert unique6 == @["a", "c", "d"]
assert unique7 == @[1, 2, 3, 4, 8]
assert unique8 == @["a", "c", "d"]
doAssert unique1 == @[1, 3, 4, 2, 8]
doAssert unique2 == @["a", "c", "d"]
doAssert unique3 == @[1, 3, 4, 2, 8]
doAssert unique4 == @["a", "c", "d"]
doAssert unique5 == @[1, 2, 3, 4, 8]
doAssert unique6 == @["a", "c", "d"]
doAssert unique7 == @[1, 2, 3, 4, 8]
doAssert unique8 == @["a", "c", "d"]
block: # zip test
let
@@ -100,29 +100,29 @@ block: # zip test
zip1 = zip(short, long)
zip2 = zip(short, words)
zip3 = zip(ashort, along)
assert zip1 == @[(1, 6), (2, 5), (3, 4)]
assert zip2 == @[(1, "one"), (2, "two"), (3, "three")]
assert zip3 == @[(1, 6), (2, 5), (3, 4)]
assert zip1[2][1] == 4
assert zip2[2][1] == "three"
assert zip3[2][1] == 4
doAssert zip1 == @[(1, 6), (2, 5), (3, 4)]
doAssert zip2 == @[(1, "one"), (2, "two"), (3, "three")]
doAssert zip3 == @[(1, 6), (2, 5), (3, 4)]
doAssert zip1[2][1] == 4
doAssert zip2[2][1] == "three"
doAssert zip3[2][1] == 4
when (NimMajor, NimMinor) <= (1, 0):
let
# In Nim 1.0.x and older, zip returned a seq of tuple strictly
# with fields named "a" and "b".
zipAb = zip(ashort, awords)
assert zipAb == @[(a: 1, b: "one"), (2, "two"), (3, "three")]
assert zipAb[2].b == "three"
doAssert zipAb == @[(a: 1, b: "one"), (2, "two"), (3, "three")]
doAssert zipAb[2].b == "three"
else:
let
# As zip returns seq of anonymous tuples, they can be assigned
# to any variable that's a sequence of named tuples too.
zipXy: seq[tuple[x: int, y: string]] = zip(ashort, awords)
zipMn: seq[tuple[m: int, n: string]] = zip(ashort, words)
assert zipXy == @[(x: 1, y: "one"), (2, "two"), (3, "three")]
assert zipMn == @[(m: 1, n: "one"), (2, "two"), (3, "three")]
assert zipXy[2].y == "three"
assert zipMn[2].n == "three"
doAssert zipXy == @[(x: 1, y: "one"), (2, "two"), (3, "three")]
doAssert zipMn == @[(m: 1, n: "one"), (2, "two"), (3, "three")]
doAssert zipXy[2].y == "three"
doAssert zipMn[2].n == "three"
block: # distribute tests
let numbers = @[1, 2, 3, 4, 5, 6, 7]
@@ -156,13 +156,13 @@ block: # map test
anumbers = [1, 4, 5, 8, 9, 7, 4]
m1 = map(numbers, proc(x: int): int = 2*x)
m2 = map(anumbers, proc(x: int): int = 2*x)
assert m1 == @[2, 8, 10, 16, 18, 14, 8]
assert m2 == @[2, 8, 10, 16, 18, 14, 8]
doAssert m1 == @[2, 8, 10, 16, 18, 14, 8]
doAssert m2 == @[2, 8, 10, 16, 18, 14, 8]
block: # apply test
var a = @["1", "2", "3", "4"]
apply(a, proc(x: var string) = x &= "42")
assert a == @["142", "242", "342", "442"]
doAssert a == @["142", "242", "342", "442"]
block: # filter proc test
let
@@ -172,34 +172,34 @@ block: # filter proc test
f2 = filter(colors) do (x: string) -> bool: x.len > 5
f3 = filter(acolors, proc(x: string): bool = x.len < 6)
f4 = filter(acolors) do (x: string) -> bool: x.len > 5
assert f1 == @["red", "black"]
assert f2 == @["yellow"]
assert f3 == @["red", "black"]
assert f4 == @["yellow"]
doAssert f1 == @["red", "black"]
doAssert f2 == @["yellow"]
doAssert f3 == @["red", "black"]
doAssert f4 == @["yellow"]
block: # filter iterator test
let numbers = @[1, 4, 5, 8, 9, 7, 4]
let anumbers = [1, 4, 5, 8, 9, 7, 4]
assert toSeq(filter(numbers, proc (x: int): bool = x mod 2 == 0)) ==
doAssert toSeq(filter(numbers, proc (x: int): bool = x mod 2 == 0)) ==
@[4, 8, 4]
assert toSeq(filter(anumbers, proc (x: int): bool = x mod 2 == 0)) ==
doAssert toSeq(filter(anumbers, proc (x: int): bool = x mod 2 == 0)) ==
@[4, 8, 4]
block: # keepIf test
var floats = @[13.0, 12.5, 5.8, 2.0, 6.1, 9.9, 10.1]
keepIf(floats, proc(x: float): bool = x > 10)
assert floats == @[13.0, 12.5, 10.1]
doAssert floats == @[13.0, 12.5, 10.1]
block: # delete tests
let outcome = @[1, 1, 1, 1, 1, 1, 1, 1]
var dest = @[1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1]
dest.delete(3, 8)
assert outcome == dest, """\
doAssert outcome == dest, """\
Deleting range 3-9 from [1,1,1,2,2,2,2,2,2,1,1,1,1,1]
is [1,1,1,1,1,1,1,1]"""
var x = @[1, 2, 3]
x.delete(100, 100)
assert x == @[1, 2, 3]
doAssert x == @[1, 2, 3]
block: # insert tests
var dest = @[1, 1, 1, 1, 1, 1, 1, 1]
@@ -207,7 +207,7 @@ block: # insert tests
src = @[2, 2, 2, 2, 2, 2]
outcome = @[1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1]
dest.insert(src, 3)
assert dest == outcome, """\
doAssert dest == outcome, """\
Inserting [2,2,2,2,2,2] into [1,1,1,1,1,1,1,1]
at 3 is [1,1,1,2,2,2,2,2,2,1,1,1,1,1]"""
@@ -216,57 +216,57 @@ block: # filterIt test
temperatures = @[-272.15, -2.0, 24.5, 44.31, 99.9, -113.44]
acceptable = filterIt(temperatures, it < 50 and it > -10)
notAcceptable = filterIt(temperatures, it > 50 or it < -10)
assert acceptable == @[-2.0, 24.5, 44.31]
assert notAcceptable == @[-272.15, 99.9, -113.44]
doAssert acceptable == @[-2.0, 24.5, 44.31]
doAssert notAcceptable == @[-272.15, 99.9, -113.44]
block: # keepItIf test
var candidates = @["foo", "bar", "baz", "foobar"]
keepItIf(candidates, it.len == 3 and it[0] == 'b')
assert candidates == @["bar", "baz"]
doAssert candidates == @["bar", "baz"]
block: # all
let
numbers = @[1, 4, 5, 8, 9, 7, 4]
anumbers = [1, 4, 5, 8, 9, 7, 4]
len0seq: seq[int] = @[]
assert all(numbers, proc (x: int): bool = return x < 10) == true
assert all(numbers, proc (x: int): bool = return x < 9) == false
assert all(len0seq, proc (x: int): bool = return false) == true
assert all(anumbers, proc (x: int): bool = return x < 10) == true
assert all(anumbers, proc (x: int): bool = return x < 9) == false
doAssert all(numbers, proc (x: int): bool = return x < 10) == true
doAssert all(numbers, proc (x: int): bool = return x < 9) == false
doAssert all(len0seq, proc (x: int): bool = return false) == true
doAssert all(anumbers, proc (x: int): bool = return x < 10) == true
doAssert all(anumbers, proc (x: int): bool = return x < 9) == false
block: # allIt
let
numbers = @[1, 4, 5, 8, 9, 7, 4]
anumbers = [1, 4, 5, 8, 9, 7, 4]
len0seq: seq[int] = @[]
assert allIt(numbers, it < 10) == true
assert allIt(numbers, it < 9) == false
assert allIt(len0seq, false) == true
assert allIt(anumbers, it < 10) == true
assert allIt(anumbers, it < 9) == false
doAssert allIt(numbers, it < 10) == true
doAssert allIt(numbers, it < 9) == false
doAssert allIt(len0seq, false) == true
doAssert allIt(anumbers, it < 10) == true
doAssert allIt(anumbers, it < 9) == false
block: # any
let
numbers = @[1, 4, 5, 8, 9, 7, 4]
anumbers = [1, 4, 5, 8, 9, 7, 4]
len0seq: seq[int] = @[]
assert any(numbers, proc (x: int): bool = return x > 8) == true
assert any(numbers, proc (x: int): bool = return x > 9) == false
assert any(len0seq, proc (x: int): bool = return true) == false
assert any(anumbers, proc (x: int): bool = return x > 8) == true
assert any(anumbers, proc (x: int): bool = return x > 9) == false
doAssert any(numbers, proc (x: int): bool = return x > 8) == true
doAssert any(numbers, proc (x: int): bool = return x > 9) == false
doAssert any(len0seq, proc (x: int): bool = return true) == false
doAssert any(anumbers, proc (x: int): bool = return x > 8) == true
doAssert any(anumbers, proc (x: int): bool = return x > 9) == false
block: # anyIt
let
numbers = @[1, 4, 5, 8, 9, 7, 4]
anumbers = [1, 4, 5, 8, 9, 7, 4]
len0seq: seq[int] = @[]
assert anyIt(numbers, it > 8) == true
assert anyIt(numbers, it > 9) == false
assert anyIt(len0seq, true) == false
assert anyIt(anumbers, it > 8) == true
assert anyIt(anumbers, it > 9) == false
doAssert anyIt(numbers, it > 8) == true
doAssert anyIt(numbers, it > 9) == false
doAssert anyIt(len0seq, true) == false
doAssert anyIt(anumbers, it > 8) == true
doAssert anyIt(anumbers, it > 9) == false
block: # toSeq test
block:
@@ -275,7 +275,7 @@ block: # toSeq test
oddNumbers = toSeq(filter(numeric) do (x: int) -> bool:
if x mod 2 == 1:
result = true)
assert oddNumbers == @[1, 3, 5, 7, 9]
doAssert oddNumbers == @[1, 3, 5, 7, 9]
block:
doAssert [1, 2].toSeq == @[1, 2]
@@ -350,10 +350,10 @@ block: # foldl tests
multiplication = foldl(numbers, a * b)
words = @["nim", "is", "cool"]
concatenation = foldl(words, a & b)
assert addition == 25, "Addition is (((5)+9)+11)"
assert subtraction == -15, "Subtraction is (((5)-9)-11)"
assert multiplication == 495, "Multiplication is (((5)*9)*11)"
assert concatenation == "nimiscool"
doAssert addition == 25, "Addition is (((5)+9)+11)"
doAssert subtraction == -15, "Subtraction is (((5)-9)-11)"
doAssert multiplication == 495, "Multiplication is (((5)*9)*11)"
doAssert concatenation == "nimiscool"
block: # foldr tests
let
@@ -363,10 +363,10 @@ block: # foldr tests
multiplication = foldr(numbers, a * b)
words = @["nim", "is", "cool"]
concatenation = foldr(words, a & b)
assert addition == 25, "Addition is (5+(9+(11)))"
assert subtraction == 7, "Subtraction is (5-(9-(11)))"
assert multiplication == 495, "Multiplication is (5*(9*(11)))"
assert concatenation == "nimiscool"
doAssert addition == 25, "Addition is (5+(9+(11)))"
doAssert subtraction == 7, "Subtraction is (5-(9-(11)))"
doAssert multiplication == 495, "Multiplication is (5*(9*(11)))"
doAssert concatenation == "nimiscool"
doAssert toSeq(1..3).foldr(a + b) == 6 # issue #14404
block: # mapIt + applyIt test
@@ -376,8 +376,8 @@ block: # mapIt + applyIt test
strings = nums.identity.mapIt($(4 * it))
doAssert counter == 1
nums.applyIt(it * 3)
assert nums[0] + nums[3] == 15
assert strings[2] == "12"
doAssert nums[0] + nums[3] == 15
doAssert strings[2] == "12"
block: # newSeqWith tests
var seq2D = newSeqWith(4, newSeq[bool](2))