remove some noises in tests (#16448)

2026-04-19 05:50:30 +00:00 · 2020-12-27 07:45:57 -06:00
parent 357729639f
commit 271f68259b
17 changed files with 140 additions and 181 deletions
--- a/tests/metatype/utypeclasses.nim
+++ b/tests/metatype/utypeclasses.nim
@@ -3,11 +3,11 @@ import unittest
 proc concat(a, b): string =
  result = $a & $b

-test "if proc param types are not supplied, the params are assumed to be generic":
+block: # if proc param types are not supplied, the params are assumed to be generic
  check concat(1, "test") == "1test"
  check concat(1, 20) == "120"
  check concat("foo", "bar") == "foobar"

-test "explicit param types can still be specified":
+block: # explicit param types can still be specified
  check concat[cstring, cstring]("x", "y") == "xy"

--- a/tests/objects/tobject.nim
+++ b/tests/objects/tobject.nim
@@ -1,7 +1,3 @@
-discard """
-output: "\n[Suite] object basic methods"
-"""
-
 import unittest

 type Obj = object
@@ -10,12 +6,12 @@ type Obj = object
 proc makeObj(x: int): Obj =
  result.foo = x

-suite "object basic methods":
-  test "it should convert an object to a string":
+block: # object basic methods
+  block: # it should convert an object to a string
    var obj = makeObj(1)
    # Should be "obj: (foo: 1)" or similar.
    check($obj == "(foo: 1)")
-  test "it should test equality based on fields":
+  block: # it should test equality based on fields
    check(makeObj(1) == makeObj(1))

 # bug #10203
--- a/tests/stdlib/nre/captures.nim
+++ b/tests/stdlib/nre/captures.nim
@@ -1,12 +1,12 @@
 import unittest, optional_nonstrict
 include nre

-suite "captures":
-  test "map capture names to numbers":
+block: # captures
+  block: # map capture names to numbers
    check(getNameToNumberTable(re("(?<v1>1(?<v2>2(?<v3>3))(?'v4'4))()")) ==
      { "v1" : 0, "v2" : 1, "v3" : 2, "v4" : 3 }.toTable())

-  test "capture bounds are correct":
+  block: # capture bounds are correct
    let ex1 = re("([0-9])")
    check("1 23".find(ex1).matchBounds == 0 .. 0)
    check("1 23".find(ex1).captureBounds[0] == 0 .. 0)
@@ -20,7 +20,7 @@ suite "captures":
    let ex3 = re("([0-9]+)")
    check("824".find(ex3).captureBounds[0] == 0 .. 2)

-  test "named captures":
+  block: # named captures
    let ex1 = "foobar".find(re("(?<foo>foo)(?<bar>bar)"))
    check(ex1.captures["foo"] == "foo")
    check(ex1.captures["bar"] == "bar")
@@ -32,7 +32,7 @@ suite "captures":
    expect KeyError:
        discard ex2.captures["bar"]

-  test "named capture bounds":
+  block: # named capture bounds
    let ex1 = "foo".find(re("(?<foo>foo)(?<bar>bar)?"))
    check("foo" in ex1.captureBounds)
    check(ex1.captureBounds["foo"] == 0..2)
@@ -40,12 +40,12 @@ suite "captures":
    expect KeyError:
        discard ex1.captures["bar"]

-  test "capture count":
+  block: # capture count
    let ex1 = re("(?<foo>foo)(?<bar>bar)?")
    check(ex1.captureCount == 2)
    check(ex1.captureNameId == {"foo" : 0, "bar" : 1}.toTable())

-  test "named capture table":
+  block: # named capture table
    let ex1 = "foo".find(re("(?<foo>foo)(?<bar>bar)?"))
    check(ex1.captures.toTable == {"foo" : "foo"}.toTable())
    check(ex1.captureBounds.toTable == {"foo" : 0..2}.toTable())
@@ -53,7 +53,7 @@ suite "captures":
    let ex2 = "foobar".find(re("(?<foo>foo)(?<bar>bar)?"))
    check(ex2.captures.toTable == {"foo" : "foo", "bar" : "bar"}.toTable())

-  test "capture sequence":
+  block: # capture sequence
    let ex1 = "foo".find(re("(?<foo>foo)(?<bar>bar)?"))
    check(ex1.captures.toSeq == @[some("foo"), none(string)])
    check(ex1.captureBounds.toSeq == @[some(0..2), none(Slice[int])])
--- a/tests/stdlib/nre/escape.nim
+++ b/tests/stdlib/nre/escape.nim
@@ -1,7 +1,7 @@
 import nre, unittest

-suite "escape strings":
-  test "escape strings":
+block: # escape strings
+  block: # escape strings
    check("123".escapeRe() == "123")
    check("[]".escapeRe() == r"\[\]")
    check("()".escapeRe() == r"\(\)")
--- a/tests/stdlib/nre/find.nim
+++ b/tests/stdlib/nre/find.nim
@@ -3,23 +3,23 @@ import nre except toSeq
 import optional_nonstrict
 import times, strutils

-suite "find":
-  test "find text":
+block: # find
+  block: # find text
    check("3213a".find(re"[a-z]").match == "a")
    check(toSeq(findIter("1 2 3 4 5 6 7 8 ", re" ")).map(
      proc (a: RegexMatch): string = a.match
    ) == @[" ", " ", " ", " ", " ", " ", " ", " "])

-  test "find bounds":
+  block: # find bounds
    check(toSeq(findIter("1 2 3 4 5 ", re" ")).map(
      proc (a: RegexMatch): Slice[int] = a.matchBounds
    ) == @[1..1, 3..3, 5..5, 7..7, 9..9])

-  test "overlapping find":
+  block: # overlapping find
    check("222".findAll(re"22") == @["22"])
    check("2222".findAll(re"22") == @["22", "22"])

-  test "len 0 find":
+  block: # len 0 find
    check("".findAll(re"\ ") == newSeq[string]())
    check("".findAll(re"") == @[""])
    check("abc".findAll(re"") == @["", "", "", ""])
@@ -27,7 +27,7 @@ suite "find":
    check("word\r\lword".findAll(re"(*ANYCRLF)(?m)$") == @["", ""])
    check("слово слово".findAll(re"(*U)\b") == @["", "", "", ""])

-  test "bail early":
+  block: # bail early
    ## we expect nothing to be found and we should be bailing out early which means that
    ## the timing difference between searching in small and large data should be well
    ## within a tolerance margin
--- a/tests/stdlib/nre/init.nim
+++ b/tests/stdlib/nre/init.nim
@@ -1,12 +1,12 @@
 import unittest
 include nre

-suite "Test NRE initialization":
-  test "correct initialization":
+block: # Test NRE initialization
+  block: # correct initialization
    check(re("[0-9]+") != nil)
    check(re("(?i)[0-9]+") != nil)

-  test "options":
+  block: # options
    check(extractOptions("(*NEVER_UTF)") ==
          ("", pcre.NEVER_UTF, true))
    check(extractOptions("(*UTF8)(*ANCHORED)(*UCP)z") ==
@@ -19,14 +19,14 @@ suite "Test NRE initialization":
    check(extractOptions("(*LIMIT_MATCH=6)(*ANCHORED)z") ==
          ("(*LIMIT_MATCH=6)z", pcre.ANCHORED, true))

-  test "incorrect options":
+  block: # incorrect options
    for s in ["CR", "(CR", "(*CR", "(*abc)", "(*abc)CR",
              "(?i)",
              "(*LIMIT_MATCH=5", "(*NO_AUTO_POSSESS=5)"]:
      let ss = s & "(*NEVER_UTF)"
      check(extractOptions(ss) == (ss, 0, true))

-  test "invalid regex":
+  block: # invalid regex
    expect(SyntaxError): discard re("[0-9")
    try:
      discard re("[0-9")
--- a/tests/stdlib/nre/match.nim
+++ b/tests/stdlib/nre/match.nim
@@ -1,12 +1,12 @@
 include nre, unittest, optional_nonstrict

-suite "match":
-  test "upper bound must be inclusive":
+block: # match
+  block: # upper bound must be inclusive
    check("abc".match(re"abc", endpos = -1) == none(RegexMatch))
    check("abc".match(re"abc", endpos = 1) == none(RegexMatch))
    check("abc".match(re"abc", endpos = 2) != none(RegexMatch))

-  test "match examples":
+  block: # match examples
    check("abc".match(re"(\w)").captures[0] == "a")
    check("abc".match(re"(?<letter>\w)").captures["letter"] == "a")
    check("abc".match(re"(\w)\w").captures[-1] == "ab")
@@ -14,5 +14,5 @@ suite "match":
    check("abc".match(re"").captureBounds[-1] == 0 .. -1)
    check("abc".match(re"abc").captureBounds[-1] == 0 .. 2)

-  test "match test cases":
+  block: # match test cases
    check("123".match(re"").matchBounds == 0 .. -1)
--- a/tests/stdlib/nre/misc.nim
+++ b/tests/stdlib/nre/misc.nim
@@ -1,11 +1,11 @@
 import unittest, nre, strutils, optional_nonstrict

-suite "Misc tests":
-  test "unicode":
+block: # Misc tests
+  block: # unicode
    check("".find(re"(*UTF8)").match == "")
    check("перевірка".replace(re"(*U)\w", "") == "")

-  test "empty or non-empty match":
+  block: # empty or non-empty match
    check("abc".findall(re"|.").join(":") == ":a::b::c:")
    check("abc".findall(re".|").join(":") == "a:b:c:")

--- a/tests/stdlib/nre/replace.nim
+++ b/tests/stdlib/nre/replace.nim
@@ -1,13 +1,13 @@
 include nre
 import unittest

-suite "replace":
-  test "replace with 0-length strings":
+block: # replace
+  block: # replace with 0-length strings
    check("".replace(re"1", proc (v: RegexMatch): string = "1") == "")
    check(" ".replace(re"", proc (v: RegexMatch): string = "1") == "1 1")
    check("".replace(re"", proc (v: RegexMatch): string = "1") == "1")

-  test "regular replace":
+  block: # regular replace
    check("123".replace(re"\d", "foo") == "foofoofoo")
    check("123".replace(re"(\d)", "$1$1") == "112233")
    check("123".replace(re"(\d)(\d)", "$1$2") == "123")
@@ -15,7 +15,7 @@ suite "replace":
    check("123".replace(re"(?<foo>\d)(\d)", "$foo$#$#") == "1123")
    check("123".replace(re"(?<foo>\d)(\d)", "${foo}$#$#") == "1123")

-  test "replacing missing captures should throw instead of segfaulting":
+  block: # replacing missing captures should throw instead of segfaulting
    expect IndexDefect: discard "ab".replace(re"(a)|(b)", "$1$2")
    expect IndexDefect: discard "b".replace(re"(a)?(b)", "$1$2")
    expect KeyError: discard "b".replace(re"(a)?", "${foo}")
--- a/tests/stdlib/nre/split.nim
+++ b/tests/stdlib/nre/split.nim
@@ -1,8 +1,8 @@
 import unittest, strutils
 include nre

-suite "string splitting":
-  test "splitting strings":
+block: # string splitting
+  block: # splitting strings
    check("1 2 3 4 5 6 ".split(re" ") == @["1", "2", "3", "4", "5", "6", ""])
    check("1  2  ".split(re(" ")) == @["1", "", "2", "", ""])
    check("1 2".split(re(" ")) == @["1", "2"])
@@ -10,22 +10,22 @@ suite "string splitting":
    check("".split(re"foo") == @[""])
    check("9".split(re"\son\s") == @["9"])

-  test "captured patterns":
+  block: # captured patterns
    check("12".split(re"(\d)") == @["", "1", "", "2", ""])

-  test "maxsplit":
+  block: # maxsplit
    check("123".split(re"", maxsplit = 2) == @["1", "23"])
    check("123".split(re"", maxsplit = 1) == @["123"])
    check("123".split(re"", maxsplit = -1) == @["1", "2", "3"])

-  test "split with 0-length match":
+  block: # split with 0-length match
    check("12345".split(re("")) == @["1", "2", "3", "4", "5"])
    check("".split(re"") == newSeq[string]())
    check("word word".split(re"\b") == @["word", " ", "word"])
    check("word\r\lword".split(re"(*ANYCRLF)(?m)$") == @["word", "\r\lword"])
    check("слово слово".split(re"(*U)(\b)") == @["", "слово", "", " ", "", "слово", ""])

-  test "perl split tests":
+  block: # perl split tests
    check("forty-two"                    .split(re"")      .join(",") == "f,o,r,t,y,-,t,w,o")
    check("forty-two"                    .split(re"", 3)   .join(",") == "f,o,rty-two")
    check("split this string"            .split(re" ")     .join(",") == "split,this,string")
@@ -47,7 +47,7 @@ suite "string splitting":
    check(""                             .split(re"")      .len       == 0)
    check(":"                            .split(re"")      .len       == 1)

-  test "start position":
+  block: # start position
    check("abc".split(re"", start = 1) == @["b", "c"])
    check("abc".split(re"", start = 2) == @["c"])
    check("abc".split(re"", start = 3) == newSeq[string]())
--- a/tests/stdlib/tmath.nim
+++ b/tests/stdlib/tmath.nim
@@ -1,18 +1,6 @@
 discard """
  action: run
-  output: '''
-
-[Suite] random int
-
-[Suite] random float
-
-[Suite] cumsum
-
-[Suite] random sample
-
-[Suite] ^
-'''
-matrix:"; -d:nimTmathCase2 -d:danger --passc:-ffast-math"
+  matrix:"; -d:nimTmathCase2 -d:danger --passc:-ffast-math"
 """

 # xxx: fix bugs for js then add: targets:"c js"
@@ -21,22 +9,22 @@ import math, random, os
 import unittest
 import sets, tables

-suite "random int":
-  test "there might be some randomness":
+block: # random int
+  block: # there might be some randomness
    var set = initHashSet[int](128)

    for i in 1..1000:
      incl(set, rand(high(int)))
    check len(set) == 1000
-  test "single number bounds work":

+  block: # single number bounds work
    var rand: int
    for i in 1..1000:
      rand = rand(1000)
      check rand < 1000
      check rand > -1
-  test "slice bounds work":

+  block: # slice bounds work
    var rand: int
    for i in 1..1000:
      rand = rand(100..1000)
@@ -45,8 +33,8 @@ suite "random int":
      else:
        check rand < 1000
      check rand >= 100
-  test " again gives new numbers":

+  block: # again gives new numbers
    var rand1 = rand(1000000)
    when not defined(js):
      os.sleep(200)
@@ -55,28 +43,29 @@ suite "random int":
    check rand1 != rand2


-suite "random float":
-  test "there might be some randomness":
+block: # random float
+  block: # there might be some randomness
    var set = initHashSet[float](128)

    for i in 1..100:
      incl(set, rand(1.0))
    check len(set) == 100
-  test "single number bounds work":

+  block: # single number bounds work
    var rand: float
    for i in 1..1000:
      rand = rand(1000.0)
      check rand < 1000.0
      check rand > -1.0
-  test "slice bounds work":

+  block: # slice bounds work
    var rand: float
    for i in 1..1000:
      rand = rand(100.0..1000.0)
      check rand < 1000.0
      check rand >= 100.0
-  test " again gives new numbers":
+
+  block: # again gives new numbers

    var rand1:float = rand(1000000.0)
    when not defined(js):
@@ -85,27 +74,27 @@ suite "random float":
    var rand2:float = rand(1000000.0)
    check rand1 != rand2

-suite "cumsum":
-  test "cumsum int seq return":
+block: # cumsum
+  block: # cumsum int seq return
    let counts = [ 1, 2, 3, 4 ]
    check counts.cumsummed == [ 1, 3, 6, 10 ]

-  test "cumsum float seq return":
+  block: # cumsum float seq return
    let counts = [ 1.0, 2.0, 3.0, 4.0 ]
    check counts.cumsummed == [ 1.0, 3.0, 6.0, 10.0 ]

-  test "cumsum int in-place":
+  block: # cumsum int in-place
    var counts = [ 1, 2, 3, 4 ]
    counts.cumsum
    check counts == [ 1, 3, 6, 10 ]

-  test "cumsum float in-place":
+  block: # cumsum float in-place
    var counts = [ 1.0, 2.0, 3.0, 4.0 ]
    counts.cumsum
    check counts == [ 1.0, 3.0, 6.0, 10.0 ]

-suite "random sample":
-  test "non-uniform array sample unnormalized int CDF":
+block: # random sample
+  block: # "non-uniform array sample unnormalized int CDF
    let values = [ 10, 20, 30, 40, 50 ] # values
    let counts = [ 4, 3, 2, 1, 0 ]      # weights aka unnormalized probabilities
    var histo = initCountTable[int]()
@@ -127,7 +116,7 @@ suite "random sample":
      let stdDev = sqrt(n * p * (1.0 - p))
      check abs(float(histo[values[i]]) - expected) <= 3.0 * stdDev

-  test "non-uniform array sample normalized float CDF":
+  block: # non-uniform array sample normalized float CDF
    let values = [ 10, 20, 30, 40, 50 ]     # values
    let counts = [ 0.4, 0.3, 0.2, 0.1, 0 ]  # probabilities
    var histo = initCountTable[int]()
@@ -146,8 +135,8 @@ suite "random sample":
      # NOTE: like unnormalized int CDF test, P(wholeTestFails) =~ 0.01.
      check abs(float(histo[values[i]]) - expected) <= 3.0 * stdDev

-suite "^":
-  test "compiles for valid types":
+block: # ^
+  block: # compiles for valid types
    check: compiles(5 ^ 2)
    check: compiles(5.5 ^ 2)
    check: compiles(5.5 ^ 2.int8)
--- a/tests/stdlib/tnet.nim
+++ b/tests/stdlib/tnet.nim
@@ -5,48 +5,48 @@ outputsub: ""
 import net, nativesockets
 import unittest

-suite "isIpAddress tests":
-  test "127.0.0.1 is valid":
+block: # isIpAddress tests
+  block: # 127.0.0.1 is valid
    check isIpAddress("127.0.0.1") == true

-  test "ipv6 localhost is valid":
+  block: # ipv6 localhost is valid
    check isIpAddress("::1") == true

-  test "fqdn is not an ip address":
+  block: # fqdn is not an ip address
    check isIpAddress("example.com") == false

-  test "random string is not an ipaddress":
+  block: # random string is not an ipaddress
    check isIpAddress("foo bar") == false

-  test "5127.0.0.1 is invalid":
+  block: # 5127.0.0.1 is invalid
    check isIpAddress("5127.0.0.1") == false

-  test "ipv6 is valid":
+  block: # ipv6 is valid
    check isIpAddress("2001:cdba:0000:0000:0000:0000:3257:9652") == true

-  test "invalid ipv6":
+  block: # invalid ipv6
    check isIpAddress("gggg:cdba:0000:0000:0000:0000:3257:9652") == false


-suite "parseIpAddress tests":
-  test "127.0.0.1 is valid":
+block: # parseIpAddress tests
+  block: # 127.0.0.1 is valid
    discard parseIpAddress("127.0.0.1")

-  test "ipv6 localhost is valid":
+  block: # ipv6 localhost is valid
    discard parseIpAddress("::1")

-  test "fqdn is not an ip address":
+  block: # fqdn is not an ip address
    expect(ValueError):
      discard parseIpAddress("example.com")

-  test "random string is not an ipaddress":
+  block: # random string is not an ipaddress
    expect(ValueError):
      discard parseIpAddress("foo bar")

-  test "ipv6 is valid":
+  block: # ipv6 is valid
    discard parseIpAddress("2001:cdba:0000:0000:0000:0000:3257:9652")

-  test "invalid ipv6":
+  block: # invalid ipv6
    expect(ValueError):
      discard parseIpAddress("gggg:cdba:0000:0000:0000:0000:3257:9652")

--- a/tests/stdlib/tnre.nim
+++ b/tests/stdlib/tnre.nim
@@ -2,25 +2,6 @@ discard """
 # Since the tests for nre are all bundled together we treat failure in one test as an nre failure
 # When running 'testament/tester' a failed check() in the test suite will cause the exit
 # codes to differ and be reported as a failure
-
-  output:
-    '''
-
-[Suite] Test NRE initialization
-
-[Suite] captures
-
-[Suite] find
-
-[Suite] string splitting
-
-[Suite] match
-
-[Suite] replace
-
-[Suite] escape strings
-
-[Suite] Misc tests'''
 """

 import nre
--- a/tests/stdlib/tparseuints.nim
+++ b/tests/stdlib/tparseuints.nim
@@ -1,13 +1,6 @@
-discard """
-  action: run
-  output: '''
-
-[Suite] parseutils
-'''
-"""
 import unittest, strutils

-suite "parseutils":
+block: # parseutils
  check: parseBiggestUInt("0") == 0'u64
  check: parseBiggestUInt("18446744073709551615") == 0xFFFF_FFFF_FFFF_FFFF'u64
  expect(ValueError):
--- a/tests/stdlib/ttimes.nim
+++ b/tests/stdlib/ttimes.nim
@@ -116,7 +116,7 @@ template usingTimezone(tz: string, body: untyped) =
    body
    putEnv("TZ", oldZone)

-suite "ttimes":
+block: # ttimes

  # Generate tests for multiple timezone files where available
  # Set the TZ env var for each test
@@ -143,7 +143,7 @@ suite "ttimes":
    test "parseTest":
      runTimezoneTests()

-  test "dst handling":
+  block: # dst handling
    usingTimezone("Europe/Stockholm"):
      # In case of an impossible time, the time is moved to after the
      # impossible time period
@@ -163,7 +163,7 @@ suite "ttimes":
      check initDateTime(21, mOct, 2017, 01, 00, 00).format(f) ==
        "2017-10-21 01:00 +02:00"

-  test "issue #6520":
+  block: # issue #6520
    usingTimezone("Europe/Stockholm"):
      var local = fromUnix(1469275200).local
      var utc = fromUnix(1469275200).utc
@@ -172,19 +172,19 @@ suite "ttimes":
      local.utcOffset = 0
      check claimedOffset == utc.toTime - local.toTime

-  test "issue #5704":
+  block: # issue #5704
    usingTimezone("Asia/Seoul"):
      let diff = parse("19700101-000000", "yyyyMMdd-hhmmss").toTime -
        parse("19000101-000000", "yyyyMMdd-hhmmss").toTime
      check diff == initDuration(seconds = 2208986872)

-  test "issue #6465":
+  block: # issue #6465
    usingTimezone("Europe/Stockholm"):
      let dt = parse("2017-03-25 12:00", "yyyy-MM-dd hh:mm")
      check $(dt + initTimeInterval(days = 1)) == "2017-03-26T12:00:00+02:00"
      check $(dt + initDuration(days = 1)) == "2017-03-26T13:00:00+02:00"

-  test "adding/subtracting time across dst":
+  block: # adding/subtracting time across dst
    usingTimezone("Europe/Stockholm"):
      let dt1 = initDateTime(26, mMar, 2017, 03, 00, 00)
      check $(dt1 - 1.seconds) == "2017-03-26T01:59:59+01:00"
@@ -192,55 +192,55 @@ suite "ttimes":
      var dt2 = initDateTime(29, mOct, 2017, 02, 59, 59)
      check  $(dt2 + 1.seconds) == "2017-10-29T02:00:00+01:00"

-  test "datetime before epoch":
+  block: # datetime before epoch
    check $fromUnix(-2147483648).utc == "1901-12-13T20:45:52Z"

-  test "incorrect inputs: empty string":
+  block: # incorrect inputs: empty string
    parseTestExcp("", "yyyy-MM-dd")

-  test "incorrect inputs: year":
+  block: # incorrect inputs: year
    parseTestExcp("20-02-19", "yyyy-MM-dd")

-  test "incorrect inputs: month number":
+  block: # incorrect inputs: month number
    parseTestExcp("2018-2-19", "yyyy-MM-dd")

-  test "incorrect inputs: month name":
+  block: # incorrect inputs: month name
    parseTestExcp("2018-Fe", "yyyy-MMM-dd")

-  test "incorrect inputs: day":
+  block: # incorrect inputs: day
    parseTestExcp("2018-02-1", "yyyy-MM-dd")

-  test "incorrect inputs: day of week":
+  block: # incorrect inputs: day of week
    parseTestExcp("2018-Feb-Mo", "yyyy-MMM-ddd")

-  test "incorrect inputs: hour":
+  block: # incorrect inputs: hour
    parseTestExcp("2018-02-19 1:30", "yyyy-MM-dd hh:mm")

-  test "incorrect inputs: minute":
+  block: # incorrect inputs: minute
    parseTestExcp("2018-02-19 16:3", "yyyy-MM-dd hh:mm")

-  test "incorrect inputs: second":
+  block: # incorrect inputs: second
    parseTestExcp("2018-02-19 16:30:0", "yyyy-MM-dd hh:mm:ss")

-  test "incorrect inputs: timezone (z)":
+  block: # incorrect inputs: timezone (z)
    parseTestExcp("2018-02-19 16:30:00 ", "yyyy-MM-dd hh:mm:ss z")

-  test "incorrect inputs: timezone (zz) 1":
+  block: # incorrect inputs: timezone (zz) 1
    parseTestExcp("2018-02-19 16:30:00 ", "yyyy-MM-dd hh:mm:ss zz")

-  test "incorrect inputs: timezone (zz) 2":
+  block: # incorrect inputs: timezone (zz) 2
    parseTestExcp("2018-02-19 16:30:00 +1", "yyyy-MM-dd hh:mm:ss zz")

-  test "incorrect inputs: timezone (zzz) 1":
+  block: # incorrect inputs: timezone (zzz) 1
    parseTestExcp("2018-02-19 16:30:00 ", "yyyy-MM-dd hh:mm:ss zzz")

-  test "incorrect inputs: timezone (zzz) 2":
+  block: # incorrect inputs: timezone (zzz) 2
    parseTestExcp("2018-02-19 16:30:00 +01:", "yyyy-MM-dd hh:mm:ss zzz")

-  test "incorrect inputs: timezone (zzz) 3":
+  block: # incorrect inputs: timezone (zzz) 3
    parseTestExcp("2018-02-19 16:30:00 +01:0", "yyyy-MM-dd hh:mm:ss zzz")

-  test "incorrect inputs: year (yyyy/uuuu)":
+  block: # incorrect inputs: year (yyyy/uuuu)
    parseTestExcp("-0001", "yyyy")
    parseTestExcp("-0001", "YYYY")
    parseTestExcp("1", "yyyy")
@@ -249,7 +249,7 @@ suite "ttimes":
    parseTestExcp("12345", "uuuu")
    parseTestExcp("-1 BC", "UUUU g")

-  test "incorrect inputs: invalid sign":
+  block: # incorrect inputs: invalid sign
    parseTestExcp("+1", "YYYY")
    parseTestExcp("+1", "dd")
    parseTestExcp("+1", "MM")
@@ -257,10 +257,10 @@ suite "ttimes":
    parseTestExcp("+1", "mm")
    parseTestExcp("+1", "ss")

-  test "_ as a separator":
+  block: # _ as a separator
    discard parse("2000_01_01", "YYYY'_'MM'_'dd")

-  test "dynamic timezone":
+  block: # dynamic timezone
    let tz = staticTz(seconds = -9000)
    let dt = initDateTime(1, mJan, 2000, 12, 00, 00, tz)
    check dt.utcOffset == -9000
@@ -269,13 +269,13 @@ suite "ttimes":
    check $dt.utc == "2000-01-01T09:30:00Z"
    check $dt.utc.inZone(tz) == $dt

-  test "isLeapYear":
+  block: # isLeapYear
    check isLeapYear(2016)
    check (not isLeapYear(2015))
    check isLeapYear(2000)
    check (not isLeapYear(1900))

-  test "TimeInterval":
+  block: # TimeInterval
    let t = fromUnix(876124714).utc # Mon 6 Oct 08:58:34 BST 1997
    # Interval tests
    let t2 = t - 2.years
@@ -287,7 +287,7 @@ suite "ttimes":
    check (t + 1.hours).toTime.toUnix == t.toTime.toUnix + 60 * 60
    check (t - 1.hours).toTime.toUnix == t.toTime.toUnix - 60 * 60

-  test "TimeInterval - months":
+  block: # TimeInterval - months
    var dt = initDateTime(1, mFeb, 2017, 00, 00, 00, utc())
    check $(dt - initTimeInterval(months = 1)) == "2017-01-01T00:00:00Z"
    dt = initDateTime(15, mMar, 2017, 00, 00, 00, utc())
@@ -296,7 +296,7 @@ suite "ttimes":
    # This happens due to monthday overflow. It's consistent with Phobos.
    check $(dt - initTimeInterval(months = 1)) == "2017-03-03T00:00:00Z"

-  test "duration":
+  block: # duration
    let d = initDuration
    check d(hours = 48) + d(days = 5) == d(weeks = 1)
    let dt = initDateTime(01, mFeb, 2000, 00, 00, 00, 0, utc()) + d(milliseconds = 1)
@@ -316,7 +316,7 @@ suite "ttimes":
    check (initDuration(seconds = 1, nanoseconds = 3) <=
      initDuration(seconds = 1, nanoseconds = 1)).not

-  test "large/small dates":
+  block: # large/small dates
    discard initDateTime(1, mJan, -35_000, 12, 00, 00, utc())
    # with local tz
    discard initDateTime(1, mJan, -35_000, 12, 00, 00)
@@ -328,7 +328,7 @@ suite "ttimes":
    let dt2 = dt + 35_001.years
    check $dt2 == "0001-01-01T12:00:01Z"

-  test "compare datetimes":
+  block: # compare datetimes
    var dt1 = now()
    var dt2 = dt1
    check dt1 == dt2
@@ -336,7 +336,7 @@ suite "ttimes":
    dt2 = dt2 + 1.seconds
    check dt1 < dt2

-  test "adding/subtracting TimeInterval":
+  block: # adding/subtracting TimeInterval
    # add/subtract TimeIntervals and Time/TimeInfo
    let now = getTime().utc
    let isSpecial = now.isLeapDay
@@ -374,14 +374,14 @@ suite "ttimes":
      check initTime(0, 101).toWinTime.fromWinTime.nanosecond == 100
      check initTime(0, 101).toWinTime.fromWinTime.nanosecond == 100

-  test "issue 7620":
+  block: # issue 7620
    let layout = "M/d/yyyy' 'h:mm:ss' 'tt' 'z"
    let t7620_am = parse("4/15/2017 12:01:02 AM +0", layout, utc())
    check t7620_am.format(layout) == "4/15/2017 12:01:02 AM Z"
    let t7620_pm = parse("4/15/2017 12:01:02 PM +0", layout, utc())
    check t7620_pm.format(layout) == "4/15/2017 12:01:02 PM Z"

-  test "format":
+  block: # format
    var dt = initDateTime(1, mJan, -0001,
                          17, 01, 02, 123_456_789,
                          staticTz(hours = 1, minutes = 2, seconds = 3))
@@ -450,7 +450,7 @@ suite "ttimes":
      doAssert dt.format("zz") == tz[2]
      doAssert dt.format("zzz") == tz[3]

-  test "format locale":
+  block: # format locale
    let loc = DateTimeLocale(
      MMM: ["Fir","Sec","Thi","Fou","Fif","Six","Sev","Eig","Nin","Ten","Ele","Twe"],
      MMMM: ["Firsty", "Secondy", "Thirdy", "Fourthy", "Fifthy", "Sixthy", "Seventhy", "Eighthy", "Ninthy", "Tenthy", "Eleventhy", "Twelfthy"],
@@ -467,7 +467,7 @@ suite "ttimes":
    check dt.format("MMM", loc) == "Fir"
    check dt.format("MMMM", loc) == "Firsty"

-  test "parse":
+  block: # parse
    check $parse("20180101", "yyyyMMdd", utc()) == "2018-01-01T00:00:00Z"
    parseTestExcp("+120180101", "yyyyMMdd")

@@ -488,7 +488,7 @@ suite "ttimes":

    parseTestExcp("2000 A", "yyyy g")

-  test "parse locale":
+  block: # parse locale
    let loc = DateTimeLocale(
      MMM: ["Fir","Sec","Thi","Fou","Fif","Six","Sev","Eig","Nin","Ten","Ele","Twe"],
      MMMM: ["Firsty", "Secondy", "Thirdy", "Fourthy", "Fifthy", "Sixthy", "Seventhy", "Eighthy", "Ninthy", "Tenthy", "Eleventhy", "Twelfthy"],
@@ -498,7 +498,7 @@ suite "ttimes":
    check $parse("02 Fir 2019", "dd MMM yyyy", utc(), loc) == "2019-01-02T00:00:00Z"
    check $parse("Fourthy 6, 2017", "MMMM d, yyyy", utc(), loc) == "2017-04-06T00:00:00Z"

-  test "timezoneConversion":
+  block: # timezoneConversion
    var l = now()
    let u = l.utc
    l = u.local
@@ -506,7 +506,7 @@ suite "ttimes":
    check l.timezone == local()
    check u.timezone == utc()

-  test "getDayOfWeek":
+  block: # getDayOfWeek
    check getDayOfWeek(01, mJan, 0000) == dSat
    check getDayOfWeek(01, mJan, -0023) == dSat
    check getDayOfWeek(21, mSep, 1900) == dFri
@@ -515,29 +515,29 @@ suite "ttimes":
    check getDayOfWeek(01, mJan, 2000) == dSat
    check getDayOfWeek(01, mJan, 2021) == dFri

-  test "between - simple":
+  block: # between - simple
    let x = initDateTime(10, mJan, 2018, 13, 00, 00)
    let y = initDateTime(11, mJan, 2018, 12, 00, 00)
    doAssert x + between(x, y) == y

-  test "between - dst start":
+  block: # between - dst start
    usingTimezone("Europe/Stockholm"):
      let x = initDateTime(25, mMar, 2018, 00, 00, 00)
      let y = initDateTime(25, mMar, 2018, 04, 00, 00)
      doAssert x + between(x, y) == y

-  test "between - empty interval":
+  block: # between - empty interval
    let x = now()
    let y = x
    doAssert x + between(x, y) == y

-  test "between - dst end":
+  block: # between - dst end
    usingTimezone("Europe/Stockholm"):
      let x = initDateTime(27, mOct, 2018, 02, 00, 00)
      let y = initDateTime(28, mOct, 2018, 01, 00, 00)
      doAssert x + between(x, y) == y

-  test "between - long day":
+  block: # between - long day
    usingTimezone("Europe/Stockholm"):
      # This day is 25 hours long in Europe/Stockholm
      let x = initDateTime(28, mOct, 2018, 00, 30, 00)
@@ -545,7 +545,7 @@ suite "ttimes":
      doAssert between(x, y) == 24.hours + 30.minutes
      doAssert x + between(x, y) == y

-  test "between - offset change edge case":
+  block: # between - offset change edge case
    # This test case is important because in this case
    # `x + between(x.utc, y.utc) == y` is not true, which is very rare.
    usingTimezone("America/Belem"):
@@ -554,19 +554,19 @@ suite "ttimes":
      doAssert x + between(x, y) == y
      doAssert y + between(y, x) == x

-  test "between - all units":
+  block: # between - all units
    let x = initDateTime(1, mJan, 2000, 00, 00, 00, utc())
    let ti = initTimeInterval(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
    let y = x + ti
    doAssert between(x, y) == ti
    doAssert between(y, x) == -ti

-  test "between - monthday overflow":
+  block: # between - monthday overflow
      let x = initDateTime(31, mJan, 2001, 00, 00, 00, utc())
      let y = initDateTime(1, mMar, 2001, 00, 00, 00, utc())
      doAssert x + between(x, y) == y

-  test "between - misc":
+  block: # between - misc
    block:
      let x = initDateTime(31, mDec, 2000, 12, 00, 00, utc())
      let y = initDateTime(01, mJan, 2001, 00, 00, 00, utc())
@@ -608,7 +608,7 @@ suite "ttimes":
      doAssert x + between(x, y) == y
      doAssert between(x, y) == 1.months + 1.weeks

-  test "default DateTime": # https://github.com/nim-lang/RFCs/issues/211
+  block: # default DateTime https://github.com/nim-lang/RFCs/issues/211
    var num = 0
    for ai in Month: num.inc
    check num == 12
@@ -634,7 +634,7 @@ suite "ttimes":
    expect(AssertionDefect): discard a.format initTimeFormat("yyyy")
    expect(AssertionDefect): discard between(a, a)

-  test "inX procs":
+  block: # inX procs
    doAssert initDuration(seconds = 1).inSeconds == 1
    doAssert initDuration(seconds = -1).inSeconds == -1
    doAssert initDuration(seconds = -1, nanoseconds = 1).inSeconds == 0
--- a/tests/system/tio.nim
+++ b/tests/system/tio.nim
@@ -22,12 +22,12 @@ proc echoLoop(str: string): string =
  while not output.atEnd:
    result.add(output.readLine)

-suite "io":
-  suite "readAll":
-    test "stdin":
+block: # io
+  block: # readAll
+    block: # stdin
      check:
        echoLoop(STRING_DATA) == STRING_DATA
-    test "file":
+    block: # file
      check:
        readFile(TEST_FILE).strip == STRING_DATA

--- a/tests/template/utemplates.nim
+++ b/tests/template/utemplates.nim
@@ -3,11 +3,11 @@ import unittest
 template t(a: int): string = "int"
 template t(a: string): string = "string"

-test "templates can be overloaded":
+block: # templates can be overloaded
  check t(10) == "int"
  check t("test") == "string"

-test "previous definitions can be further overloaded or hidden in local scopes":
+block: # previous definitions can be further overloaded or hidden in local scopes
  template t(a: bool): string = "bool"

  check t(true) == "bool"
@@ -17,7 +17,7 @@ test "previous definitions can be further overloaded or hidden in local scopes":
  check t(10) == "inner int"
  check t("test") == "string"

-test "templates can be redefined multiple times":
+block: # templates can be redefined multiple times
  template customAssert(cond: bool, msg: string): typed {.dirty.} =
    if not cond: fail(msg)