Merge pull request #1 from nim-lang/devel

upstream

17 files changed, 1108 insertions, 164 deletions

diff --git a/tests/stdlib/somesql.sql b/tests/stdlib/somesql.sql
new file mode 100644
index 000000000..285f93cec
--- /dev/null
+++ b/tests/stdlib/somesql.sql
@@ -0,0 +1,298 @@
+create table anon40(
+  anon41 anon42 primary key default anon43(),
+  anon44 text unique not null,
+  anon45 text unique not null,
+  anon46 text not null,
+  anon47 text not null,
+  anon48 text default null,
+  anon49 text default null,
+  anon50 text default null,
+  anon51 text default null,
+  anon52 text default null,
+  anon53 text default null,
+  anon54 text default null,
+  anon55 text default null,
+  anon56 text default null,
+  anon57 text default null,
+  anon58 text default null,
+  anon59 text default null,
+  anon60 text default null,
+  anon61 text default null,
+  anon62 varchar(30) default null,
+  anon63 varchar(30) default null);
+create table anon64(
+  anon41 serial  primary key,
+  anon65 varchar(30) not null unique,
+  anon46 varchar(30) not null,
+  anon66 varchar(30) not null,
+  anon47 varchar(30) not null,
+  anon67 text not null,
+  anon55 varchar(30) not null unique,
+  anon68 varchar(30) default 'o',
+  anon69 boolean default true,
+  anon70 int not null  references anon40(anon41));
+create table anon71(
+  anon72 varchar(30) not null  primary key,
+  anon73 varchar(30) not null unique,
+  anon70 int not null  references anon40(anon41));
+create table anon74(
+  anon72 varchar(30) not null  primary key,
+  anon73 varchar(30) not null unique,
+  anon75 varchar(30) not null,
+  anon70 int not null references anon40(anon41),
+  foreign key(anon75) references anon71(anon72));
+create table anon76(
+  anon41 serial  primary key,
+  anon72 varchar(30) not null unique,
+  anon73 varchar(30) not null unique,
+  anon77 varchar(30) not null,
+  anon70 int not null  references anon40(anon41),
+  foreign key(anon77) references anon74(anon72));
+create table anon78(
+  anon41 serial  primary key,
+  anon72 varchar(30) not null unique,
+  anon73 varchar(30) not null unique,
+  anon79 int not null,
+  anon80 varchar(30) default null,
+  anon81 int not null,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41),
+  foreign key(anon79) references anon78(anon41),
+  foreign key(anon81) references anon76(anon41));
+create table anon82(
+  anon41 serial  primary key,
+  anon72 varchar(30) not null unique,
+  anon73 text not null unique,
+  anon79 int not null,
+  anon80 text default null,
+  anon83 varchar(30) not null default 'd',
+  anon84 decimal default 0.00,
+  anon69 boolean not null default true,
+  anon85 decimal default 0.00,
+  anon86 decimal default 0.00,
+  anon87 decimal default 0.00,
+  anon70 int not null  references anon40(anon41),
+  foreign key(anon79) references anon78(anon41));
+create table anon88(
+  anon41 serial  primary key,
+  anon72 varchar(30) not null unique,
+  anon80 text default '',
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon89(
+  anon90 int not null  primary key,
+  anon91 anon92 default 0.00,
+  anon93 varchar(30),
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41),
+  foreign key(anon90) references anon82(anon41));
+create table anon94(
+  anon41 serial  primary key,
+  anon73 text unique not null,
+  anon80 text default null,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon95(
+  anon41 serial  primary key,
+  anon73 text unique not null,
+  anon96 int not null  references anon94(anon41),
+  anon80 text default null,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon97(
+  anon41 serial  primary key,
+  anon73 text unique not null,
+  anon98 int not null  references anon95(anon41),
+  anon80 text default null,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon99(
+  anon41 serial  primary key,
+  anon73 varchar(30) unique not null,
+  anon100 varchar(30) default null,
+  anon101 anon102 default 0,
+  anon103 varchar(30) default 'g',
+  anon104 int not null,
+  anon105 decimal not null default 1,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon106(
+  anon107 varchar(30) default 'g',
+  anon108 int  references anon99(anon41) not null,
+  anon109 decimal default 1,
+  anon110 int  references anon99(anon41) not null,
+  anon70 int not null  references anon40(anon41));
+create table anon111(
+  anon41 serial  primary key,
+  anon112 text unique not null,
+  anon73 text unique not null,
+  anon113 anon102  references anon97(anon41) not null,
+  anon114 varchar(30) not null,
+  anon115 int not null  references anon88(anon41),
+  anon116 int not null  references anon82(anon41),
+  anon117 int not null  references anon82(anon41),
+  anon118 int not null  references anon82(anon41),
+  anon119 int not null  references anon82(anon41),
+  anon120 int not null  references anon82(anon41),
+  anon121 int not null  references anon82(anon41),
+  anon122 int  references anon99(anon41) not null,
+  anon123 decimal default 0.00,
+  anon124 decimal default 0.00,
+  anon69 boolean default true,
+  anon70 int not null  references anon40(anon41));
+create table anon125(
+  anon41 serial  primary key,
+  anon126 int  references anon111(anon41) not null,
+  anon80 text not null,
+  anon127 varchar(30) not null,
+  anon128 decimal default 0.00,
+  anon129 decimal default 0,
+  anon130 decimal default 0,
+  anon131 decimal default 0,
+  anon132 decimal default 0,
+  anon133 decimal default 0.00,
+  anon134 decimal default 0.00,
+  anon135 decimal default 0.00,
+  anon70 int not null  references anon40(anon41),  constraint anon136 check anon137(anon126, anon127, anon129));
+create table anon138(
+  anon41 serial  primary key,
+  anon126 int  references anon111(anon41) not null,
+  anon80 text not null,
+  anon127 varchar(30) not null,
+  anon139 date not null,
+  anon129 decimal default 0,
+  anon130 decimal default 0,
+  anon131 decimal default 0,
+  anon132 decimal default 0,
+  anon70 int not null  references anon40(anon41),  constraint anon136 check anon137(anon127, anon129));
+create table anon140(
+  anon41 serial  primary key,
+  anon141 text unique not null,
+  anon46 text default null,
+  anon47 text default null,
+  anon57 varchar(30) default null,
+  anon142 text default null,
+  anon51 text default null,
+  anon143 varchar(30) default null,
+  anon53 text default null,
+  anon54 text default null,
+  anon55 text default null,
+  anon45 text default null,
+  anon69 boolean default true,
+  anon70 int not null  references anon40(anon41));
+create table anon144(
+  anon41 serial  primary key,
+  anon72 varchar(30) unique not null,
+  anon73 varchar(30) unique not null,
+  anon80 varchar(30) default null,
+  anon69 boolean default true,
+  anon70 int not null  references anon40(anon41));
+create table anon145(
+  anon41 serial  primary key,
+  anon72 varchar(30) unique not null,
+  anon73 varchar(30) unique not null,
+  anon146 int not null,
+  anon147 anon92 default 1,
+  anon148 anon92 default 9999999,
+  anon80 varchar(30) default null,
+  anon69 boolean default true,
+  anon149 int default 0,
+  anon150 int not null,
+  anon151 anon92 default 0,
+  anon70 int not null  references anon40(anon41),
+  foreign key(anon150) references anon82(anon41),
+  foreign key(anon146) references anon144(anon41));
+create table anon152(
+  anon41 serial  primary key,
+  anon73 varchar(30) not null unique,
+  anon153 varchar(30) not null unique,
+  anon80 text default null,
+  anon69 boolean not null default true,
+  anon70 int not null  references anon40(anon41));
+create table anon154(
+  anon41 serial  primary key not null,
+  anon155 int not null unique,
+  date date default anon156 not null,
+  anon157 anon102  references anon140(anon41) not null,
+  anon158 anon102  references anon64(anon41) not null,
+  anon159 decimal default 0 not null,
+  anon160 decimal default 0 not null,
+  anon161 decimal default 0 not null,
+  anon162 decimal default 0 not null,
+  anon163 decimal default 0 not null,
+  anon164 decimal default 0 not null,
+  anon165 decimal default 0.00,
+  anon166 decimal default 0 not null,
+  anon167 decimal default 0.00,
+  anon168 decimal default 0 not null,
+  anon169 boolean default false,
+  anon170 varchar(30) default 'ca',
+  anon171 varchar(30) default 'n',
+  anon172 varchar(30) not null default 'd',
+  anon173 decimal default 0.00,
+  anon174 decimal default 0.00,
+  anon175 int,
+  anon176 varchar(30) default null,
+  anon177 varchar(30) default '',
+  anon178 varchar(30) default null,
+  anon70 int not null  references anon40(anon41));
+create table anon179(
+  anon41 serial  primary key not null,
+  anon180 anon102  references anon154(anon41) not null,
+  anon181 int  references anon125(anon41) not null,
+  anon182 int  references anon82(anon41) not null,
+  anon122 int  references anon99(anon41) not null,
+  anon183 decimal not null,
+  anon184 decimal default 0.00,
+  anon174 decimal default 0,
+  anon160 decimal default 0.00,
+  anon185 decimal default 0,
+  anon162 decimal default 0.00,
+  anon186 decimal default 0,
+  anon163 decimal default 0.00,
+  anon187 decimal default 0,
+  anon164 decimal default 0.00,
+  anon188 decimal default 0,
+  anon161 decimal default 0.00,
+  anon189 decimal default 0.00,
+  anon168 decimal default 0.00,
+  anon190 decimal not null,
+  anon191 decimal default 0,
+  anon83 varchar(30) not null default 't',
+  anon192 decimal default 0,
+  anon193 decimal not null,
+  anon194 decimal not null,
+  anon70 int not null  references anon40(anon41));
+create table anon195(
+  anon41 serial not null,
+  anon196 int not null,
+  anon175 char not null,
+  anon90 int not null  references anon82,
+  anon165 decimal default 0.00,
+  anon70 int not null  references anon40(anon41),  primary key(anon196, anon175));
+create table anon197(
+  anon41 serial not null,
+  anon196 int not null,
+  anon175 char not null,
+  anon198 int not null,
+  anon189 decimal default 0.00,
+  anon199 varchar(30) default null,
+  anon200 varchar(30) default null,
+  anon70 int not null  references anon40(anon41),
+  primary key(anon196, anon175),
+  foreign key(anon198) references anon145(anon41));
+create table anon201(
+  anon41 serial  primary key,
+  anon202 varchar(30) not null,
+  anon203 varchar(30) not null,
+  anon204 varchar(30) not null,
+  anon205 varchar(30) not null,
+  anon206 boolean default null,
+  anon70 int not null  references anon40(anon41));
+create table anon207(
+  anon41 serial  primary key,
+  anon208 varchar(30) not null,
+  anon209 varchar(30) not null,
+  anon204 varchar(30) default null,
+  anon70 int not null  references anon40(anon41));
+
diff --git a/tests/stdlib/tfrexp1.nim b/tests/stdlib/tfrexp1.nim
new file mode 100644
index 000000000..c6bb2b38c
--- /dev/null
+++ b/tests/stdlib/tfrexp1.nim
@@ -0,0 +1,44 @@
+discard """
+  targets: "js c c++"
+  output: '''ok'''
+"""
+
+import math
+import strformat
+
+const manualTest = false
+
+proc frexp_test(lo, hi, step: float64) =
+  var exp: int
+  var frac: float64
+
+  var eps = 1e-15.float64
+
+  var x:float64 = lo
+  while x <= hi:
+    frac = frexp(x.float, exp)
+    let rslt = pow(2.0, float(exp)) * frac
+
+    doAssert(abs(rslt - x) < eps)
+
+    when manualTest:
+      echo fmt("x: {x:10.3f} exp: {exp:4d} frac: {frac:24.20f} check: {$(abs(rslt - x) < eps):-5s} {rslt: 9.3f}")
+    x += step
+
+when manualTest:
+  var exp: int
+  var frac: float64
+
+  for flval in [1.7976931348623157e+308, -1.7976931348623157e+308, # max, min float64
+                3.4028234663852886e+38, -3.4028234663852886e+38,   # max, min float32
+                4.9406564584124654e-324, -4.9406564584124654e-324, # smallest/largest positive/negative float64
+                1.4012984643248171e-45, -1.4012984643248171e-45,   # smallest/largest positive/negative float32
+                2.2250738585072014e-308, 1.1754943508222875e-38]:  # smallest normal float64/float32
+    frac = frexp(flval, exp)
+    echo fmt("{flval:25.16e}, {exp: 6d}, {frac: .20f} {frac * pow(2.0, float(exp)): .20e}")
+
+  frexp_test(-1000.0, 1000.0, 0.0125)
+else:
+  frexp_test(-1000000.0, 1000000.0, 0.125)
+
+echo "ok"
diff --git a/tests/stdlib/tgetfileinfo.nim b/tests/stdlib/tgetfileinfo.nim
index 1c897b702..019c2eb7f 100644
--- a/tests/stdlib/tgetfileinfo.nim
+++ b/tests/stdlib/tgetfileinfo.nim
@@ -61,7 +61,7 @@ proc testGetFileInfo =
   block:
     let
       testFile = open(getAppFilename())
-      testHandle = fileHandle(testFile)
+      testHandle = getFileHandle(testFile)
     try:
       discard getFileInfo(testFile)
       #echo("Handle : Valid File : Success")
diff --git a/tests/stdlib/thttpclient.nim b/tests/stdlib/thttpclient.nim
index e759e2977..fff02722a 100644
--- a/tests/stdlib/thttpclient.nim
+++ b/tests/stdlib/thttpclient.nim
@@ -2,6 +2,8 @@ discard """
   cmd: "nim c --threads:on -d:ssl $file"
   exitcode: 0
   output: "OK"
+  disabled: "travis"
+  disabled: "appveyor"
 """
 
 import strutils
diff --git a/tests/stdlib/tjsonmacro.nim b/tests/stdlib/tjsonmacro.nim
index 153cf8556..2cdd82305 100644
--- a/tests/stdlib/tjsonmacro.nim
+++ b/tests/stdlib/tjsonmacro.nim
@@ -2,7 +2,7 @@ discard """
   file: "tjsonmacro.nim"
   output: ""
 """
-import json, strutils
+import json, strutils, options, tables
 
 when isMainModule:
   # Tests inspired by own use case (with some additional tests).
@@ -246,4 +246,138 @@ when isMainModule:
     var b = Bird(age: 3, height: 1.734, name: "bardo", colors: [red, blue])
     let jnode = %b
     let data = jnode.to(Bird)
-    doAssert data == b
\ No newline at end of file
+    doAssert data == b
+
+  block:
+    type
+      MsgBase = ref object of RootObj
+        name*: string
+
+      MsgChallenge = ref object of MsgBase
+        challenge*: string
+
+    let data = %*{"name": "foo", "challenge": "bar"}
+    let msg = data.to(MsgChallenge)
+    doAssert msg.name == "foo"
+    doAssert msg.challenge == "bar"
+
+  block:
+    type
+      Color = enum Red, Brown
+      Thing = object
+        animal: tuple[fur: bool, legs: int]
+        color: Color
+
+    var j = parseJson("""
+      {"animal":{"fur":true,"legs":6},"color":"Red"}
+    """)
+
+    let parsed = to(j, Thing)
+    doAssert parsed.animal.fur
+    doAssert parsed.animal.legs == 6
+    doAssert parsed.color == Red
+
+  block:
+    type
+      Car = object
+        engine: tuple[name: string, capacity: float]
+        model: string
+
+    let j = """
+      {"engine": {"name": "V8", "capacity": 5.5}, "model": "Skyline"}
+    """
+
+    var i = 0
+    proc mulTest: JsonNode =
+      i.inc()
+      return parseJson(j)
+
+    let parsed = mulTest().to(Car)
+    doAssert parsed.engine.name == "V8"
+
+    doAssert i == 1
+
+  block:
+    # Option[T] support!
+    type
+      Car1 = object # TODO: Codegen bug when `Car`
+        engine: tuple[name: string, capacity: Option[float]]
+        model: string
+        year: Option[int]
+
+    let noYear = """
+      {"engine": {"name": "V8", "capacity": 5.5}, "model": "Skyline"}
+    """
+
+    let noYearParsed = parseJson(noYear)
+    let noYearDeser = to(noYearParsed, Car1)
+    doAssert noYearDeser.engine.capacity == some(5.5)
+    doAssert noYearDeser.year.isNone
+    doAssert noYearDeser.engine.name == "V8"
+
+  # Table[T, Y] support.
+  block:
+    type
+      Friend = object
+        name: string
+        age: int
+
+      Dynamic = object
+        name: string
+        friends: Table[string, Friend]
+
+    let data = """
+      {"friends": {
+                    "John": {"name": "John", "age": 35},
+                    "Elizabeth": {"name": "Elizabeth", "age": 23}
+                  }, "name": "Dominik"}
+    """
+
+    let dataParsed = parseJson(data)
+    let dataDeser = to(dataParsed, Dynamic)
+    doAssert dataDeser.name == "Dominik"
+    doAssert dataDeser.friends["John"].age == 35
+    doAssert dataDeser.friends["Elizabeth"].age == 23
+
+  # JsonNode support
+  block:
+    type
+      Test = object
+        name: string
+        fallback: JsonNode
+
+    let data = """
+      {"name": "FooBar", "fallback": 56.42}
+    """
+
+    let dataParsed = parseJson(data)
+    let dataDeser = to(dataParsed, Test)
+    doAssert dataDeser.name == "FooBar"
+    doAssert dataDeser.fallback.kind == JFloat
+    doAssert dataDeser.fallback.getFloat() == 56.42
+
+  # int64, float64 etc support.
+  block:
+    type
+      Test1 = object
+        a: int8
+        b: int16
+        c: int32
+        d: int64
+        e: uint8
+        f: uint16
+        g: uint32
+        h: uint64
+        i: float32
+        j: float64
+
+    let data = """
+      {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7,
+       "h": 8, "i": 9.9, "j": 10.10}
+    """
+
+    let dataParsed = parseJson(data)
+    let dataDeser = to(dataParsed, Test1)
+    doAssert dataDeser.a == 1
+    doAssert dataDeser.f == 6
+    doAssert dataDeser.i == 9.9'f32
\ No newline at end of file
diff --git a/tests/stdlib/tjsonmacro_reject.nim b/tests/stdlib/tjsonmacro_reject.nim
new file mode 100644
index 000000000..00506449f
--- /dev/null
+++ b/tests/stdlib/tjsonmacro_reject.nim
@@ -0,0 +1,18 @@
+discard """
+  file: "tjsonmacro_reject.nim"
+  line: 11
+  errormsg: "Use a named tuple instead of: (string, float)"
+"""
+
+import json
+
+type
+  Car = object
+    engine: (string, float)
+    model: string
+
+let j = """
+  {"engine": {"name": "V8", "capacity": 5.5}, model: "Skyline"}
+"""
+let parsed = parseJson(j)
+echo(to(parsed, Car))
\ No newline at end of file
diff --git a/tests/stdlib/tjsonmacro_reject2.nim b/tests/stdlib/tjsonmacro_reject2.nim
new file mode 100644
index 000000000..b01153553
--- /dev/null
+++ b/tests/stdlib/tjsonmacro_reject2.nim
@@ -0,0 +1,21 @@
+discard """
+  file: "tjsonmacro_reject2.nim"
+  line: 10
+  errormsg: "The `to` macro does not support ref objects with cycles."
+"""
+import json
+
+type
+  Misdirection = object
+    cycle: Cycle
+
+  Cycle = ref object
+    foo: string
+    cycle: Misdirection
+
+let data = """
+  {"cycle": null}
+"""
+
+let dataParsed = parseJson(data)
+let dataDeser = to(dataParsed, Cycle)
\ No newline at end of file
diff --git a/tests/stdlib/tlists.nim b/tests/stdlib/tlists.nim
index 4caa05c90..37e73c53f 100644
--- a/tests/stdlib/tlists.nim
+++ b/tests/stdlib/tlists.nim
@@ -17,7 +17,7 @@ block SinglyLinkedListTest1:
 block SinglyLinkedListTest2:
   var L: TSinglyLinkedList[string]
   for d in items(data): L.prepend($d)
-  assert($L == "[6, 5, 4, 3, 2, 1]")
+  assert($L == """["6", "5", "4", "3", "2", "1"]""")
 
   assert("4" in L)
 
diff --git a/tests/stdlib/tmemfiles2.nim b/tests/stdlib/tmemfiles2.nim
index 665e92e8a..7ea94cffc 100644
--- a/tests/stdlib/tmemfiles2.nim
+++ b/tests/stdlib/tmemfiles2.nim
@@ -1,10 +1,8 @@
 discard """
   file: "tmemfiles2.nim"
-  disabled: true
   output: '''Full read size: 20
 Half read size: 10 Data: Hello'''
 """
-# doesn't work on windows. fmReadWrite doesn't create a file.
 import memfiles, os
 var
   mm, mm_full, mm_half: MemFile
diff --git a/tests/stdlib/tnetdial.nim b/tests/stdlib/tnetdial.nim
index da6088d70..695150179 100644
--- a/tests/stdlib/tnetdial.nim
+++ b/tests/stdlib/tnetdial.nim
@@ -2,6 +2,7 @@ discard """
   cmd: "nim c --threads:on $file"
   exitcode: 0
   output: "OK"
+  disabled: "travis"
 """
 
 import os, net, nativesockets, asyncdispatch
diff --git a/tests/stdlib/tparsesql.nim b/tests/stdlib/tparsesql.nim
new file mode 100644
index 000000000..3dc949ea1
--- /dev/null
+++ b/tests/stdlib/tparsesql.nim
@@ -0,0 +1,191 @@
+discard """
+  file: "tparsesql.nim"
+"""
+
+import parsesql
+
+doAssert $parseSQL("SELECT foo FROM table;") == "select foo from table;"
+doAssert $parseSQL("""
+SELECT
+  CustomerName,
+  ContactName,
+  Address,
+  City,
+  PostalCode,
+  Country,
+  CustomerName,
+  ContactName,
+  Address,
+  City,
+  PostalCode,
+  Country
+FROM table;""") == "select CustomerName, ContactName, Address, City, PostalCode, Country, CustomerName, ContactName, Address, City, PostalCode, Country from table;"
+
+doAssert $parseSQL("SELECT foo FROM table limit 10") == "select foo from table limit 10;"
+doAssert $parseSQL("SELECT foo, bar, baz FROM table limit 10") == "select foo, bar, baz from table limit 10;"
+doAssert $parseSQL("SELECT foo AS bar FROM table") == "select foo as bar from table;"
+doAssert $parseSQL("SELECT foo AS foo_prime, bar AS bar_prime, baz AS baz_prime FROM table") == "select foo as foo_prime, bar as bar_prime, baz as baz_prime from table;"
+doAssert $parseSQL("SELECT * FROM table") == "select * from table;"
+
+
+#TODO add count(*)
+#doAssert $parseSQL("SELECT COUNT(*) FROM table"
+
+doAssert $parseSQL("""
+SELECT * FROM table
+WHERE a = b and c = d
+""") == "select * from table where a = b and c = d;"
+
+doAssert $parseSQL("""
+SELECT * FROM table
+WHERE not b
+""") == "select * from table where not b;"
+
+doAssert $parseSQL("""
+SELECT
+  *
+FROM
+  table
+WHERE
+  a and not b
+""") == "select * from table where a and not b;"
+
+doAssert $parseSQL("""
+SELECT * FROM table
+WHERE a = b and c = d or n is null and not b + 1 = 3
+""") == "select * from table where a = b and c = d or n is null and not b + 1 = 3;"
+
+doAssert $parseSQL("""
+SELECT * FROM table
+WHERE (a = b and c = d) or (n is null and not b + 1 = 3)
+""") == "select * from table where(a = b and c = d) or (n is null and not b + 1 = 3);"
+
+doAssert $parseSQL("""
+SELECT * FROM table
+HAVING a = b and c = d
+""") == "select * from table having a = b and c = d;"
+
+doAssert $parseSQL("""
+SELECT a, b FROM table
+GROUP BY a
+""") == "select a, b from table group by a;"
+
+doAssert $parseSQL("""
+SELECT a, b FROM table
+GROUP BY 1, 2
+""") == "select a, b from table group by 1, 2;"
+
+doAssert $parseSQL("SELECT t.a FROM t as t") == "select t.a from t as t;"
+
+doAssert $parseSQL("""
+SELECT a, b FROM (
+  SELECT * FROM t
+)
+""") == "select a, b from(select * from t);"
+
+doAssert $parseSQL("""
+SELECT a, b FROM (
+  SELECT * FROM t
+) as foo
+""") == "select a, b from(select * from t) as foo;"
+
+doAssert $parseSQL("""
+SELECT a, b FROM (
+  SELECT * FROM (
+    SELECT * FROM (
+      SELECT * FROM (
+        SELECT * FROM innerTable as inner1
+      ) as inner2
+    ) as inner3
+  ) as inner4
+) as inner5
+""") == "select a, b from(select * from(select * from(select * from(select * from innerTable as inner1) as inner2) as inner3) as inner4) as inner5;"
+
+doAssert $parseSQL("""
+SELECT a, b FROM
+  (SELECT * FROM a),
+  (SELECT * FROM b),
+  (SELECT * FROM c)
+""") == "select a, b from(select * from a),(select * from b),(select * from c);"
+
+doAssert $parseSQL("""
+SELECT * FROM Products
+WHERE Price BETWEEN 10 AND 20;
+""") == "select * from Products where Price between 10 and 20;"
+
+doAssert $parseSQL("""
+SELECT id FROM a
+JOIN b
+ON a.id == b.id
+""") == "select id from a join b on a.id == b.id;"
+
+doAssert $parseSQL("""
+SELECT id FROM a
+JOIN (SELECT id from c) as b
+ON a.id == b.id
+""") == "select id from a join(select id from c) as b on a.id == b.id;"
+
+doAssert $parseSQL("""
+SELECT id FROM a
+INNER JOIN b
+ON a.id == b.id
+""") == "select id from a inner join b on a.id == b.id;"
+
+doAssert $parseSQL("""
+SELECT id FROM a
+OUTER JOIN b
+ON a.id == b.id
+""") == "select id from a outer join b on a.id == b.id;"
+
+doAssert $parseSQL("""
+SELECT id FROM a
+CROSS JOIN b
+ON a.id == b.id
+""") == "select id from a cross join b on a.id == b.id;"
+
+doAssert $parseSQL("""
+CREATE TYPE happiness AS ENUM ('happy', 'very happy', 'ecstatic');
+CREATE TABLE holidays (
+  num_weeks int,
+  happiness happiness
+);
+CREATE INDEX table1_attr1 ON table1(attr1);
+SELECT * FROM myTab WHERE col1 = 'happy';
+""") == "create type happiness as enum ('happy' , 'very happy' , 'ecstatic' ); create table holidays(num_weeks  int , happiness  happiness );; create index table1_attr1 on table1(attr1 );; select * from myTab where col1 = 'happy';"
+
+doAssert $parseSQL("""
+INSERT INTO Customers (CustomerName, ContactName, Address, City, PostalCode, Country)
+VALUES ('Cardinal', 'Tom B. Erichsen', 'Skagen 21', 'Stavanger', '4006', 'Norway');
+""") == "insert into Customers (CustomerName , ContactName , Address , City , PostalCode , Country ) values ('Cardinal' , 'Tom B. Erichsen' , 'Skagen 21' , 'Stavanger' , '4006' , 'Norway' );"
+
+doAssert $parseSQL("""
+INSERT INTO TableName DEFAULT VALUES
+""") == "insert into TableName default values;"
+
+doAssert $parseSQL("""
+UPDATE Customers
+SET ContactName = 'Alfred Schmidt', City= 'Frankfurt'
+WHERE CustomerID = 1;
+""") == "update Customers set ContactName  = 'Alfred Schmidt' , City  = 'Frankfurt' where CustomerID = 1;"
+
+doAssert $parseSQL("DELETE FROM table_name;") == "delete from table_name;"
+
+doAssert $parseSQL("DELETE * FROM table_name;") == "delete from table_name;"
+
+doAssert $parseSQL("""
+--Select all:
+SELECT * FROM Customers;
+""") == "select * from Customers;"
+
+doAssert $parseSQL("""
+SELECT * FROM Customers WHERE (CustomerName LIKE 'L%'
+OR CustomerName LIKE 'R%' /*OR CustomerName LIKE 'S%'
+OR CustomerName LIKE 'T%'*/ OR CustomerName LIKE 'W%')
+AND Country='USA'
+ORDER BY CustomerName;
+""") == "select * from Customers where(CustomerName like 'L%' or CustomerName like 'R%' or CustomerName like 'W%') and Country = 'USA' order by CustomerName;"
+
+# parse keywords as identifires
+doAssert $parseSQL("""
+SELECT `SELECT`, `FROM` as `GROUP` FROM `WHERE`;
+""") == """select "SELECT", "FROM" as "GROUP" from "WHERE";"""
diff --git a/tests/stdlib/treloop.nim b/tests/stdlib/treloop.nim
index 35236708c..b4221525d 100644
--- a/tests/stdlib/treloop.nim
+++ b/tests/stdlib/treloop.nim
@@ -1,5 +1,5 @@
 discard """
-  output: "@[(, +,  1,  2, )]"
+  output: '''@["(", "+", " 1", " 2", ")"]'''
 """
 
 import re
diff --git a/tests/stdlib/tsqlparser.nim b/tests/stdlib/tsqlparser.nim
new file mode 100644
index 000000000..4a7b2f7d7
--- /dev/null
+++ b/tests/stdlib/tsqlparser.nim
@@ -0,0 +1,12 @@
+discard """
+  output: '''true'''
+"""
+
+# Just check that we can parse 'somesql' and render it without crashes.
+
+import parsesql, streams, os
+
+var tree = parseSql(newFileStream(getAppDir() / "somesql.sql"), "somesql")
+discard renderSql(tree)
+
+echo "true"
diff --git a/tests/stdlib/tstring.nim b/tests/stdlib/tstring.nim
index ddf533a17..660746150 100644
--- a/tests/stdlib/tstring.nim
+++ b/tests/stdlib/tstring.nim
@@ -50,6 +50,30 @@ proc test_string_slice() =
   s[2..0] = numbers
   doAssert s == "ab1234567890cdefghijklmnopqrstuvwxyz"
 
+  # bug #6223
+  doAssertRaises(IndexError):
+    discard s[0..999]
+
   echo("OK")
 
+proc test_string_cmp() =
+  let world = "hello\0world"
+  let earth = "hello\0earth"
+  let short = "hello\0"
+  let hello = "hello"
+  let goodbye = "goodbye"
+
+  doAssert world == world
+  doAssert world != earth
+  doAssert world != short
+  doAssert world != hello
+  doAssert world != goodbye
+
+  doAssert cmp(world, world) == 0
+  doAssert cmp(world, earth) > 0
+  doAssert cmp(world, short) > 0
+  doAssert cmp(world, hello) > 0
+  doAssert cmp(world, goodbye) > 0
+
 test_string_slice()
+test_string_cmp()
diff --git a/tests/stdlib/tstrutil.nim b/tests/stdlib/tstrutil.nim
index fef1b38c2..071dae5a7 100644
--- a/tests/stdlib/tstrutil.nim
+++ b/tests/stdlib/tstrutil.nim
@@ -13,15 +13,13 @@ proc testStrip() =
 proc testRemoveSuffix =
   var s = "hello\n\r"
   s.removeSuffix
-  assert s == "hello\n"
-  s.removeSuffix
   assert s == "hello"
   s.removeSuffix
   assert s == "hello"
 
   s = "hello\n\n"
   s.removeSuffix
-  assert s == "hello\n"
+  assert s == "hello"
 
   s = "hello\r"
   s.removeSuffix
@@ -41,7 +39,31 @@ proc testRemoveSuffix =
   s.removeSuffix({'s','z'})
   assert s == "hello"
   s.removeSuffix({'l','o'})
-  assert s == "hell"
+  assert s == "he"
+
+  s = "aeiou"
+  s.removeSuffix("")
+  assert s == "aeiou"
+
+  s = ""
+  s.removeSuffix("")
+  assert s == ""
+
+  s = "  "
+  s.removeSuffix
+  assert s == "  "
+
+  s = "  "
+  s.removeSuffix("")
+  assert s == "  "
+
+  s = "    "
+  s.removeSuffix(" ")
+  assert s == "   "
+
+  s = "    "
+  s.removeSuffix(' ')
+  assert s == ""
 
   # Contrary to Chomp in other languages
   # empty string does not change behaviour
@@ -49,9 +71,71 @@ proc testRemoveSuffix =
   s.removeSuffix("")
   assert s == "hello\r\n\r\n"
 
+proc testRemovePrefix =
+  var s = "\n\rhello"
+  s.removePrefix
+  assert s == "hello"
+  s.removePrefix
+  assert s == "hello"
+
+  s = "\n\nhello"
+  s.removePrefix
+  assert s == "hello"
+
+  s = "\rhello"
+  s.removePrefix
+  assert s == "hello"
+
+  s = "hello \n there"
+  s.removePrefix
+  assert s == "hello \n there"
+
+  s = "hello"
+  s.removePrefix("hel")
+  assert s == "lo"
+  s.removePrefix('l')
+  assert s == "o"
+
+  s = "hellos"
+  s.removePrefix({'h','e'})
+  assert s == "llos"
+  s.removePrefix({'l','o'})
+  assert s == "s"
+
+  s = "aeiou"
+  s.removePrefix("")
+  assert s == "aeiou"
+
+  s = ""
+  s.removePrefix("")
+  assert s == ""
+
+  s = "  "
+  s.removePrefix
+  assert s == "  "
+
+  s = "  "
+  s.removePrefix("")
+  assert s == "  "
+
+  s = "    "
+  s.removePrefix(" ")
+  assert s == "   "
+
+  s = "    "
+  s.removePrefix(' ')
+  assert s == ""
+
+  # Contrary to Chomp in other languages
+  # empty string does not change behaviour
+  s = "\r\n\r\nhello"
+  s.removePrefix("")
+  assert s == "\r\n\r\nhello"
+
 proc main() =
   testStrip()
   testRemoveSuffix()
+  testRemovePrefix()
   for p in split("/home/a1:xyz:/usr/bin", {':'}):
     write(stdout, p)
 
@@ -64,6 +148,25 @@ proc testDelete =
   delete(s, 0, 0)
   assert s == "1236789ABCDEFG"
 
+
+proc testIsAlphaNumeric =
+  assert isAlphaNumeric("abcdABC1234") == true
+  assert isAlphaNumeric("a") == true
+  assert isAlphaNumeric("abcABC?1234") == false
+  assert isAlphaNumeric("abcABC 1234") == false
+  assert isAlphaNumeric(".") == false
+
+testIsAlphaNumeric()
+
+proc testIsDigit =
+  assert isDigit("1") == true
+  assert isDigit("1234") == true
+  assert isDigit("abcABC?1234") == false
+  assert isDigit(".") == false
+  assert isDigit(":") == false
+
+testIsDigit()
+
 proc testFind =
   assert "0123456789ABCDEFGH".find('A') == 10
   assert "0123456789ABCDEFGH".find('A', 5) == 10
diff --git a/tests/stdlib/ttimes.nim b/tests/stdlib/ttimes.nim
index 05c91ccb2..a6ac186cc 100644
--- a/tests/stdlib/ttimes.nim
+++ b/tests/stdlib/ttimes.nim
@@ -1,16 +1,17 @@
 # test the new time module
 discard """
   file: "ttimes.nim"
-  action: "run"
+  output: '''[Suite] ttimes
+'''
 """
 
 import
-  times, strutils
+  times, os, strutils, unittest
 
 # $ date --date='@2147483647'
 # Tue 19 Jan 03:14:07 GMT 2038
 
-proc checkFormat(t: TimeInfo, format, expected: string) =
+proc checkFormat(t: DateTime, format, expected: string) =
   let actual = t.format(format)
   if actual != expected:
     echo "Formatting failure!"
@@ -18,7 +19,7 @@ proc checkFormat(t: TimeInfo, format, expected: string) =
     echo "actual  : ", actual
     doAssert false
 
-let t = getGMTime(fromSeconds(2147483647))
+let t = fromUnix(2147483647).utc
 t.checkFormat("ddd dd MMM hh:mm:ss yyyy", "Tue 19 Jan 03:14:07 2038")
 t.checkFormat("ddd ddMMMhh:mm:ssyyyy", "Tue 19Jan03:14:072038")
 t.checkFormat("d dd ddd dddd h hh H HH m mm M MM MMM MMMM s" &
@@ -27,107 +28,41 @@ t.checkFormat("d dd ddd dddd h hh H HH m mm M MM MMM MMMM s" &
 
 t.checkFormat("yyyyMMddhhmmss", "20380119031407")
 
-let t2 = getGMTime(fromSeconds(160070789)) # Mon 27 Jan 16:06:29 GMT 1975
+let t2 = fromUnix(160070789).utc # Mon 27 Jan 16:06:29 GMT 1975
 t2.checkFormat("d dd ddd dddd h hh H HH m mm M MM MMM MMMM s" &
   " ss t tt y yy yyy yyyy yyyyy z zz zzz",
   "27 27 Mon Monday 4 04 16 16 6 06 1 01 Jan January 29 29 P PM 5 75 975 1975 01975 +0 +00 +00:00")
 
-var t4 = getGMTime(fromSeconds(876124714)) # Mon  6 Oct 08:58:34 BST 1997
+var t4 = fromUnix(876124714).utc # Mon  6 Oct 08:58:34 BST 1997
 t4.checkFormat("M MM MMM MMMM", "10 10 Oct October")
 
 # Interval tests
 (t4 - initInterval(years = 2)).checkFormat("yyyy", "1995")
 (t4 - initInterval(years = 7, minutes = 34, seconds = 24)).checkFormat("yyyy mm ss", "1990 24 10")
 
-proc parseTest(s, f, sExpected: string, ydExpected: int) =
-  let
-    parsed = s.parse(f)
-    parsedStr = $getGMTime(toTime(parsed))
-  if parsedStr != sExpected:
-    echo "Parsing failure!"
-    echo "expected: ", sExpected
-    echo "actual  : ", parsedStr
-    doAssert false
-  doAssert(parsed.yearday == ydExpected)
-proc parseTestTimeOnly(s, f, sExpected: string) =
-  doAssert(sExpected in $s.parse(f))
-
-# because setting a specific timezone for testing is platform-specific, we use
-# explicit timezone offsets in all tests.
-
-parseTest("Tuesday at 09:04am on Dec 15, 2015 +0",
-    "dddd at hh:mmtt on MMM d, yyyy z", "2015-12-15T09:04:00+00:00", 348)
-# ANSIC       = "Mon Jan _2 15:04:05 2006"
-parseTest("Thu Jan 12 15:04:05 2006 +0", "ddd MMM dd HH:mm:ss yyyy z",
-    "2006-01-12T15:04:05+00:00", 11)
-# UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
-parseTest("Thu Jan 12 15:04:05 2006 +0", "ddd MMM dd HH:mm:ss yyyy z",
-    "2006-01-12T15:04:05+00:00", 11)
-# RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
-parseTest("Mon Feb 29 15:04:05 -07:00 2016 +0", "ddd MMM dd HH:mm:ss zzz yyyy z",
-    "2016-02-29T15:04:05+00:00", 59) # leap day
-# RFC822      = "02 Jan 06 15:04 MST"
-parseTest("12 Jan 16 15:04 +0", "dd MMM yy HH:mm z",
-    "2016-01-12T15:04:00+00:00", 11)
-# RFC822Z     = "02 Jan 06 15:04 -0700" # RFC822 with numeric zone
-parseTest("01 Mar 16 15:04 -07:00", "dd MMM yy HH:mm zzz",
-    "2016-03-01T22:04:00+00:00", 60) # day after february in leap year
-# RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
-parseTest("Monday, 12-Jan-06 15:04:05 +0", "dddd, dd-MMM-yy HH:mm:ss z",
-    "2006-01-12T15:04:05+00:00", 11)
-# RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
-parseTest("Sun, 01 Mar 2015 15:04:05 +0", "ddd, dd MMM yyyy HH:mm:ss z",
-    "2015-03-01T15:04:05+00:00", 59) # day after february in non-leap year
-# RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" # RFC1123 with numeric zone
-parseTest("Thu, 12 Jan 2006 15:04:05 -07:00", "ddd, dd MMM yyyy HH:mm:ss zzz",
-    "2006-01-12T22:04:05+00:00", 11)
-# RFC3339     = "2006-01-02T15:04:05Z07:00"
-parseTest("2006-01-12T15:04:05Z-07:00", "yyyy-MM-ddTHH:mm:ssZzzz",
-    "2006-01-12T22:04:05+00:00", 11)
-parseTest("2006-01-12T15:04:05Z-07:00", "yyyy-MM-dd'T'HH:mm:ss'Z'zzz",
-    "2006-01-12T22:04:05+00:00", 11)
-# RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
-parseTest("2006-01-12T15:04:05.999999999Z-07:00",
-    "yyyy-MM-ddTHH:mm:ss.999999999Zzzz", "2006-01-12T22:04:05+00:00", 11)
-for tzFormat in ["z", "zz", "zzz"]:
-  # formatting timezone as 'Z' for UTC
-  parseTest("2001-01-12T22:04:05Z", "yyyy-MM-dd'T'HH:mm:ss" & tzFormat,
-      "2001-01-12T22:04:05+00:00", 11)
-# Kitchen     = "3:04PM"
-parseTestTimeOnly("3:04PM", "h:mmtt", "15:04:00")
-#when not defined(testing):
-#  echo "Kitchen: " & $s.parse(f)
-#  var ti = timeToTimeInfo(getTime())
-#  echo "Todays date after decoding: ", ti
-#  var tint = timeToTimeInterval(getTime())
-#  echo "Todays date after decoding to interval: ", tint
-
 # checking dayOfWeek matches known days
-doAssert getDayOfWeek(21, 9, 1900) == dFri
-doAssert getDayOfWeek(1, 1, 1970) == dThu
-doAssert getDayOfWeek(21, 9, 1970) == dMon
-doAssert getDayOfWeek(1, 1, 2000) == dSat
-doAssert getDayOfWeek(1, 1, 2021) == dFri
-# Julian tests
-doAssert getDayOfWeekJulian(21, 9, 1900) == dFri
-doAssert getDayOfWeekJulian(21, 9, 1970) == dMon
-doAssert getDayOfWeekJulian(1, 1, 2000) == dSat
-doAssert getDayOfWeekJulian(1, 1, 2021) == dFri
-
-# toSeconds tests with GM timezone
-let t4L = getGMTime(fromSeconds(876124714))
-doAssert toSeconds(toTime(t4L)) == 876124714
-doAssert toSeconds(toTime(t4L)) + t4L.timezone.float == toSeconds(toTime(t4))
+doAssert getDayOfWeek(01, mJan, 0000) == dSat
+doAssert getDayOfWeek(01, mJan, -0023) == dSat
+doAssert getDayOfWeek(21, mSep, 1900) == dFri
+doAssert getDayOfWeek(01, mJan, 1970) == dThu
+doAssert getDayOfWeek(21, mSep, 1970) == dMon
+doAssert getDayOfWeek(01, mJan, 2000) == dSat
+doAssert getDayOfWeek(01, mJan, 2021) == dFri
+
+# toUnix tests with GM timezone
+let t4L = fromUnix(876124714).utc
+doAssert toUnix(toTime(t4L)) == 876124714
+doAssert toUnix(toTime(t4L)) + t4L.utcOffset == toUnix(toTime(t4))
 
 # adding intervals
 var
-  a1L = toSeconds(toTime(t4L + initInterval(hours = 1))) + t4L.timezone.float
-  a1G = toSeconds(toTime(t4)) + 60.0 * 60.0
+  a1L = toUnix(toTime(t4L + initInterval(hours = 1))) + t4L.utcOffset
+  a1G = toUnix(toTime(t4)) + 60 * 60
 doAssert a1L == a1G
 
 # subtracting intervals
-a1L = toSeconds(toTime(t4L - initInterval(hours = 1))) + t4L.timezone.float
-a1G = toSeconds(toTime(t4)) - (60.0 * 60.0)
+a1L = toUnix(toTime(t4L - initInterval(hours = 1))) + t4L.utcOffset
+a1G = toUnix(toTime(t4)) - (60 * 60)
 doAssert a1L == a1G
 
 # add/subtract TimeIntervals and Time/TimeInfo
@@ -143,45 +78,16 @@ doAssert ti1 == getTime()
 ti1 += 1.days
 doAssert ti1 == getTime() + 1.days
 
-# overflow of TimeIntervals on initalisation
-doAssert initInterval(milliseconds = 25000) == initInterval(seconds = 25)
-doAssert initInterval(seconds = 65) == initInterval(seconds = 5, minutes = 1)
-doAssert initInterval(hours = 25) == initInterval(hours = 1, days = 1)
-doAssert initInterval(months = 13) == initInterval(months = 1, years = 1)
-
 # Bug with adding a day to a Time
 let day = 24.hours
 let tomorrow = getTime() + day
 doAssert tomorrow - getTime() == 60*60*24
 
-doAssert milliseconds(1000 * 60) == minutes(1)
-doAssert milliseconds(1000 * 60 * 60) == hours(1)
-doAssert milliseconds(1000 * 60 * 60 * 24) == days(1)
-doAssert seconds(60 * 60) == hours(1)
-doAssert seconds(60 * 60 * 24) == days(1)
-doAssert seconds(60 * 60 + 65) == (hours(1) + minutes(1) + seconds(5))
-
-# Bug with parse not setting DST properly if the current local DST differs from
-# the date being parsed. Need to test parse dates both in and out of DST. We
-# are testing that be relying on the fact that tranforming a TimeInfo to a Time
-# and back again will correctly set the DST value. With the incorrect parse
-# behavior this will introduce a one hour offset from the named time and the
-# parsed time if the DST value differs between the current time and the date we
-# are parsing.
-#
-# Unfortunately these tests depend on the locale of the system in which they
-# are run. They will not be meaningful when run in a locale without DST. They
-# also assume that Jan. 1 and Jun. 1 will have differing isDST values.
-let dstT1 = parse("2016-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss")
-let dstT2 = parse("2016-06-01 00:00:00", "yyyy-MM-dd HH:mm:ss")
-doAssert dstT1 == getLocalTime(toTime(dstT1))
-doAssert dstT2 == getLocalTime(toTime(dstT2))
-
 # Comparison between Time objects should be detected by compiler
 # as 'noSideEffect'.
 proc cmpTimeNoSideEffect(t1: Time, t2: Time): bool {.noSideEffect.} =
   result = t1 == t2
-doAssert cmpTimeNoSideEffect(0.fromSeconds, 0.fromSeconds)
+doAssert cmpTimeNoSideEffect(0.fromUnix, 0.fromUnix)
 # Additionally `==` generic for seq[T] has explicit 'noSideEffect' pragma
 # so we can check above condition by comparing seq[Time] sequences
 let seqA: seq[Time] = @[]
@@ -195,43 +101,197 @@ for tz in [
     (-1800, "+0", "+00", "+00:30"), # half an hour
     (7200, "-2", "-02", "-02:00"), # positive
     (38700, "-10", "-10", "-10:45")]: # positive with three quaters hour
-  let ti = TimeInfo(monthday: 1, timezone: tz[0])
+  let ti = DateTime(month: mJan, monthday: 1, utcOffset: tz[0])
   doAssert ti.format("z") == tz[1]
   doAssert ti.format("zz") == tz[2]
   doAssert ti.format("zzz") == tz[3]
 
-block formatDst:
-  var ti = TimeInfo(monthday: 1, isDst: true)
-
-  # BST
-  ti.timezone = 0
-  doAssert ti.format("z") == "+1"
-  doAssert ti.format("zz") == "+01"
-  doAssert ti.format("zzz") == "+01:00"
-
-  # EDT
-  ti.timezone = 5 * 60 * 60 
-  doAssert ti.format("z") == "-4"
-  doAssert ti.format("zz") == "-04"
-  doAssert ti.format("zzz") == "-04:00"
-
-block dstTest:
-  let nonDst = TimeInfo(year: 2015, month: mJan, monthday: 01, yearday: 0,
-      weekday: dThu, hour: 00, minute: 00, second: 00, isDST: false, timezone: 0)
-  var dst = nonDst
-  dst.isDst = true
-  # note that both isDST == true and isDST == false are valid here because
-  # DST is in effect on January 1st in some southern parts of Australia.
-  # FIXME: Fails in UTC
-  # doAssert nonDst.toTime() - dst.toTime() == 3600
-  doAssert nonDst.format("z") == "+0"
-  doAssert dst.format("z") == "+1"
-
-  # parsing will set isDST in relation to the local time. We take a date in
-  # January and one in July to maximize the probability to hit one date with DST
-  # and one without on the local machine. However, this is not guaranteed.
+block countLeapYears:
+  # 1920, 2004 and 2020 are leap years, and should be counted starting at the following year
+  doAssert countLeapYears(1920) + 1 == countLeapYears(1921)
+  doAssert countLeapYears(2004) + 1 == countLeapYears(2005)
+  doAssert countLeapYears(2020) + 1 == countLeapYears(2021)
+
+block timezoneConversion:
+  var l = now()
+  let u = l.utc
+  l = u.local
+
+  doAssert l.timezone == local()
+  doAssert u.timezone == utc()
+
+template parseTest(s, f, sExpected: string, ydExpected: int) =
   let
-    parsedJan = parse("2016-01-05 04:00:00+01:00", "yyyy-MM-dd HH:mm:sszzz")
-    parsedJul = parse("2016-07-01 04:00:00+01:00", "yyyy-MM-dd HH:mm:sszzz")
-  doAssert toTime(parsedJan) == fromSeconds(1451962800)
-  doAssert toTime(parsedJul) == fromSeconds(1467342000)
+    parsed = s.parse(f, utc())
+    parsedStr = $parsed
+  check parsedStr == sExpected
+  if parsed.yearday != ydExpected:
+    echo s
+    echo parsed.repr
+    echo parsed.yearday, " exp: ", ydExpected
+  check(parsed.yearday == ydExpected)
+
+template parseTestTimeOnly(s, f, sExpected: string) =
+  check sExpected in $s.parse(f, utc())
+
+# because setting a specific timezone for testing is platform-specific, we use
+# explicit timezone offsets in all tests.
+template runTimezoneTests() =
+  parseTest("Tuesday at 09:04am on Dec 15, 2015 +0",
+      "dddd at hh:mmtt on MMM d, yyyy z", "2015-12-15T09:04:00+00:00", 348)
+  # ANSIC       = "Mon Jan _2 15:04:05 2006"
+  parseTest("Thu Jan 12 15:04:05 2006 +0", "ddd MMM dd HH:mm:ss yyyy z",
+      "2006-01-12T15:04:05+00:00", 11)
+  # UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
+  parseTest("Thu Jan 12 15:04:05 2006 +0", "ddd MMM dd HH:mm:ss yyyy z",
+      "2006-01-12T15:04:05+00:00", 11)
+  # RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
+  parseTest("Mon Feb 29 15:04:05 -07:00 2016 +0", "ddd MMM dd HH:mm:ss zzz yyyy z",
+      "2016-02-29T15:04:05+00:00", 59) # leap day
+  # RFC822      = "02 Jan 06 15:04 MST"
+  parseTest("12 Jan 16 15:04 +0", "dd MMM yy HH:mm z",
+      "2016-01-12T15:04:00+00:00", 11)
+  # RFC822Z     = "02 Jan 06 15:04 -0700" # RFC822 with numeric zone
+  parseTest("01 Mar 16 15:04 -07:00", "dd MMM yy HH:mm zzz",
+      "2016-03-01T22:04:00+00:00", 60) # day after february in leap year
+  # RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
+  parseTest("Monday, 12-Jan-06 15:04:05 +0", "dddd, dd-MMM-yy HH:mm:ss z",
+      "2006-01-12T15:04:05+00:00", 11)
+  # RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
+  parseTest("Sun, 01 Mar 2015 15:04:05 +0", "ddd, dd MMM yyyy HH:mm:ss z",
+      "2015-03-01T15:04:05+00:00", 59) # day after february in non-leap year
+  # RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" # RFC1123 with numeric zone
+  parseTest("Thu, 12 Jan 2006 15:04:05 -07:00", "ddd, dd MMM yyyy HH:mm:ss zzz",
+      "2006-01-12T22:04:05+00:00", 11)
+  # RFC3339     = "2006-01-02T15:04:05Z07:00"
+  parseTest("2006-01-12T15:04:05Z-07:00", "yyyy-MM-ddTHH:mm:ssZzzz",
+      "2006-01-12T22:04:05+00:00", 11)
+  parseTest("2006-01-12T15:04:05Z-07:00", "yyyy-MM-dd'T'HH:mm:ss'Z'zzz",
+      "2006-01-12T22:04:05+00:00", 11)
+  # RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
+  parseTest("2006-01-12T15:04:05.999999999Z-07:00",
+      "yyyy-MM-ddTHH:mm:ss.999999999Zzzz", "2006-01-12T22:04:05+00:00", 11)
+  for tzFormat in ["z", "zz", "zzz"]:
+    # formatting timezone as 'Z' for UTC
+    parseTest("2001-01-12T22:04:05Z", "yyyy-MM-dd'T'HH:mm:ss" & tzFormat,
+        "2001-01-12T22:04:05+00:00", 11)
+  # Kitchen     = "3:04PM"
+  parseTestTimeOnly("3:04PM", "h:mmtt", "15:04:00")
+  #when not defined(testing):
+  #  echo "Kitchen: " & $s.parse(f)
+  #  var ti = timeToTimeInfo(getTime())
+  #  echo "Todays date after decoding: ", ti
+  #  var tint = timeToTimeInterval(getTime())
+  #  echo "Todays date after decoding to interval: ", tint
+
+  # Bug with parse not setting DST properly if the current local DST differs from
+  # the date being parsed. Need to test parse dates both in and out of DST. We
+  # are testing that be relying on the fact that tranforming a TimeInfo to a Time
+  # and back again will correctly set the DST value. With the incorrect parse
+  # behavior this will introduce a one hour offset from the named time and the
+  # parsed time if the DST value differs between the current time and the date we
+  # are parsing.
+  let dstT1 = parse("2016-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss")
+  let dstT2 = parse("2016-06-01 00:00:00", "yyyy-MM-dd HH:mm:ss")
+  check dstT1 == toTime(dstT1).local
+  check dstT2 == toTime(dstT2).local
+
+  block dstTest:
+    # parsing will set isDST in relation to the local time. We take a date in
+    # January and one in July to maximize the probability to hit one date with DST
+    # and one without on the local machine. However, this is not guaranteed.
+    let
+      parsedJan = parse("2016-01-05 04:00:00+01:00", "yyyy-MM-dd HH:mm:sszzz")
+      parsedJul = parse("2016-07-01 04:00:00+01:00", "yyyy-MM-dd HH:mm:sszzz")
+    doAssert toTime(parsedJan) == fromUnix(1451962800)
+    doAssert toTime(parsedJul) == fromUnix(1467342000)
+
+suite "ttimes":
+
+  # Generate tests for multiple timezone files where available
+  # Set the TZ env var for each test
+  when defined(Linux) or defined(macosx):
+    const tz_dir = "/usr/share/zoneinfo"
+    const f = "yyyy-MM-dd HH:mm zzz"
+    
+    let orig_tz = getEnv("TZ")
+    var tz_cnt = 0
+    for tz_fn in walkFiles(tz_dir & "/*"):
+      if symlinkExists(tz_fn) or tz_fn.endsWith(".tab") or
+          tz_fn.endsWith(".list"):
+        continue
+
+      test "test for " & tz_fn:
+        tz_cnt.inc
+        putEnv("TZ", tz_fn)
+        runTimezoneTests()
+
+    test "enough timezone files tested":
+      check tz_cnt > 10
+
+    test "dst handling":
+      putEnv("TZ", "Europe/Stockholm")
+      # In case of an impossible time, the time is moved to after the impossible time period
+      check initDateTime(26, mMar, 2017, 02, 30, 00).format(f) == "2017-03-26 03:30 +02:00"
+      # In case of an ambiguous time, the earlier time is choosen
+      check initDateTime(29, mOct, 2017, 02, 00, 00).format(f) == "2017-10-29 02:00 +02:00"
+      # These are just dates on either side of the dst switch
+      check initDateTime(29, mOct, 2017, 01, 00, 00).format(f) == "2017-10-29 01:00 +02:00"
+      check initDateTime(29, mOct, 2017, 01, 00, 00).isDst
+      check initDateTime(29, mOct, 2017, 03, 01, 00).format(f) == "2017-10-29 03:01 +01:00"
+      check (not initDateTime(29, mOct, 2017, 03, 01, 00).isDst)
+      
+      check initDateTime(21, mOct, 2017, 01, 00, 00).format(f) == "2017-10-21 01:00 +02:00"
+
+    test "issue #6520":
+      putEnv("TZ", "Europe/Stockholm")
+      var local = fromUnix(1469275200).local
+      var utc = fromUnix(1469275200).utc
+
+      let claimedOffset = local.utcOffset
+      local.utcOffset = 0
+      check claimedOffset == utc.toTime - local.toTime
+
+    test "issue #5704":
+      putEnv("TZ", "Asia/Seoul")
+      let diff = parse("19700101-000000", "yyyyMMdd-hhmmss").toTime - parse("19000101-000000", "yyyyMMdd-hhmmss").toTime
+      check diff == 2208986872
+
+    test "issue #6465":
+      putEnv("TZ", "Europe/Stockholm")      
+      let dt = parse("2017-03-25 12:00", "yyyy-MM-dd hh:mm")
+      check $(dt + 1.days) == "2017-03-26T12:00:00+02:00"
+
+    test "datetime before epoch":
+      check $fromUnix(-2147483648).utc == "1901-12-13T20:45:52+00:00"
+
+    test "adding/subtracting time across dst":
+      putenv("TZ", "Europe/Stockholm")
+
+      let dt1 = initDateTime(26, mMar, 2017, 03, 00, 00)
+      check $(dt1 - 1.seconds) == "2017-03-26T01:59:59+01:00"
+
+      var dt2 = initDateTime(29, mOct, 2017, 02, 59, 59)
+      check  $(dt2 + 1.seconds) == "2017-10-29T02:00:00+01:00"
+
+    putEnv("TZ", orig_tz)
+
+  else:
+    # not on Linux or macosx: run one parseTest only
+    test "parseTest":
+      runTimezoneTests()
+
+  test "isLeapYear":
+    check isLeapYear(2016)
+    check (not isLeapYear(2015))
+    check isLeapYear(2000)
+    check (not isLeapYear(1900))
+
+  test "subtract months":
+    var dt = initDateTime(1, mFeb, 2017, 00, 00, 00, utc())
+    check $(dt - 1.months) == "2017-01-01T00:00:00+00:00"
+    dt = initDateTime(15, mMar, 2017, 00, 00, 00, utc())
+    check $(dt - 1.months) == "2017-02-15T00:00:00+00:00"
+    dt = initDateTime(31, mMar, 2017, 00, 00, 00, utc())
+    # This happens due to monthday overflow. It's consistent with Phobos.
+    check $(dt - 1.months) == "2017-03-03T00:00:00+00:00"
\ No newline at end of file
diff --git a/tests/stdlib/tunittest.nim b/tests/stdlib/tunittest.nim
index e4a801871..86b9fd037 100644
--- a/tests/stdlib/tunittest.nim
+++ b/tests/stdlib/tunittest.nim
@@ -13,6 +13,8 @@ discard """
 
 [Suite] bug #5784
 
+[Suite] test name filtering
+
 '''
 """
 
@@ -120,3 +122,39 @@ suite "bug #5784":
       field: int
     var obj: Obj
     check obj.isNil or obj.field == 0
+
+when defined(testing):
+  suite "test name filtering":
+    test "test name":
+      check matchFilter("suite1", "foo", "")
+      check matchFilter("suite1", "foo", "foo")
+      check matchFilter("suite1", "foo", "::")
+      check matchFilter("suite1", "foo", "*")
+      check matchFilter("suite1", "foo", "::foo")
+      check matchFilter("suite1", "::foo", "::foo")
+
+    test "test name - glob":
+      check matchFilter("suite1", "foo", "f*")
+      check matchFilter("suite1", "foo", "*oo")
+      check matchFilter("suite1", "12345", "12*345")
+      check matchFilter("suite1", "q*wefoo", "q*wefoo")
+      check false == matchFilter("suite1", "foo", "::x")
+      check false == matchFilter("suite1", "foo", "::x*")
+      check false == matchFilter("suite1", "foo", "::*x")
+      #  overlap
+      check false == matchFilter("suite1", "12345", "123*345")
+      check matchFilter("suite1", "ab*c::d*e::f", "ab*c::d*e::f")
+
+    test "suite name":
+      check matchFilter("suite1", "foo", "suite1::")
+      check false == matchFilter("suite1", "foo", "suite2::")
+      check matchFilter("suite1", "qwe::foo", "qwe::foo")
+      check matchFilter("suite1", "qwe::foo", "suite1::qwe::foo")
+
+    test "suite name - glob":
+      check matchFilter("suite1", "foo", "::*")
+      check matchFilter("suite1", "foo", "*::*")
+      check matchFilter("suite1", "foo", "*::foo")
+      check false == matchFilter("suite1", "foo", "*ite2::")
+      check matchFilter("suite1", "q**we::foo", "q**we::foo")
+      check matchFilter("suite1", "a::b*c::d*e", "a::b*c::d*e")