cleaned up twchartoutf8 test

tests/stdlib/twchartoutf8.nim

@@ -1,106 +1,110 @@
+discard """
+  output: '''OK'''
+"""
+
 #assume WideCharToMultiByte always produce correct result
 #windows only
 
 when not defined(windows):
-  {.error: "windows only".}
+  echo "OK"
+else:
+  {.push gcsafe.}
 
-{.push gcsafe.}
+  const CP_UTF8 = 65001'i32
 
-const CP_UTF8 = 65001'i32
+  type
+    LPBOOL = ptr int32
+    LPWCSTR = ptr uint16
 
-type
+  proc WideCharToMultiByte*(CodePage: int32, dwFlags: int32,
-  LPBOOL = ptr int32
+                            lpWideCharStr: LPWCSTR, cchWideChar: int32,
-  LPWCSTR = ptr uint16
+                            lpMultiByteStr: cstring, cchMultiByte: int32,
+                            lpDefaultChar: cstring, lpUsedDefaultChar: LPBOOL): int32{.
+      stdcall, dynlib: "kernel32", importc: "WideCharToMultiByte".}
 
-proc WideCharToMultiByte*(CodePage: int32, dwFlags: int32,
+  {.pop.}
-                          lpWideCharStr: LPWCSTR, cchWideChar: int32,
-                          lpMultiByteStr: cstring, cchMultiByte: int32,
-                          lpDefaultChar: cstring, lpUsedDefaultChar: LPBOOL): int32{.
-    stdcall, dynlib: "kernel32", importc: "WideCharToMultiByte".}
 
-{.pop.}
+  proc convertToUTF8(wc: WideCString, wclen: int32): string =
+    let size = WideCharToMultiByte(CP_UTF8, 0'i32, cast[LPWCSTR](addr(wc[0])), wclen,
+      cstring(nil), 0'i32, cstring(nil), LPBOOL(nil))
+    result = newString(size)
+    let res = WideCharToMultiByte(CP_UTF8, 0'i32, cast[LPWCSTR](addr(wc[0])), wclen,
+      cstring(result), size, cstring(nil), LPBOOL(nil))
+    result[size] = chr(0)
+    doAssert size == res
 
-proc convertToUTF8(wc: WideCString, wclen: int32): string =
+  proc testCP(wc: WideCString, lo, hi: int) =
-  let size = WideCharToMultiByte(CP_UTF8, 0'i32, cast[LPWCSTR](addr(wc[0])), wclen, 
+    var x = 0
-    cstring(nil), 0'i32, cstring(nil), LPBOOL(nil))
+    let chunk = 1024
-  result = newString(size)
+    for i in lo..hi:
-  let res = WideCharToMultiByte(CP_UTF8, 0'i32, cast[LPWCSTR](addr(wc[0])), wclen, 
+      wc[x] = cast[Utf16Char](i)
-    cstring(result), size, cstring(nil), LPBOOL(nil))
+      if (x >= chunk) or (i >= hi):
-  result[size] = chr(0)
+        wc[x] = Utf16Char(0)
-  assert size == res
+        var a = convertToUTF8(wc, int32(x))
+        var b = wc $ chunk
+        doAssert a == b
+        x = 0
+      inc x
 
-proc testCP(wc: WideCString, lo, hi: int) =
+  proc testCP2(wc: WideCString, lo, hi: int) =
-  var x = 0
+    doAssert((lo >= 0x10000) and (hi <= 0x10FFFF))
-  let chunk = 1024
+    var x = 0
-  for i in lo..hi:
+    let chunk = 1024
-    wc[x] = cast[Utf16Char](i)
+    for i in lo..hi:
-    if (x >= chunk) or (i >= hi):
+      let ch = i - 0x10000
-      wc[x] = Utf16Char(0)
+      let W1 = 0xD800 or (ch shr 10)
-      var a = convertToUTF8(wc, int32(x))
+      let W2 = 0xDC00 or (0x3FF and ch)
-      var b = wc $ chunk
+      wc[x] = cast[Utf16Char](W1)
-      assert a == b
+      wc[x+1] = cast[Utf16Char](W2)
-      x = 0
+      inc(x, 2)
-    inc x
 
-proc testCP2(wc: WideCString, lo, hi: int) =
+      if (x >= chunk) or (i >= hi):
-  assert((lo >= 0x10000) and (hi <= 0x10FFFF))
+        wc[x] = Utf16Char(0)
-  var x = 0
+        var a = convertToUTF8(wc, int32(x))
-  let chunk = 1024
+        var b = wc $ chunk
-  for i in lo..hi:
+        doAssert a == b
-    let ch = i - 0x10000
+        x = 0
-    let W1 = 0xD800 or (ch shr 10)
-    let W2 = 0xDC00 or (0x3FF and ch)
-    wc[x] = cast[Utf16Char](W1)
-    wc[x+1] = cast[Utf16Char](W2)
-    inc(x, 2)
 
-    if (x >= chunk) or (i >= hi):
+  #RFC-2781 "UTF-16, an encoding of ISO 10646"
-      wc[x] = Utf16Char(0)
-      var a = convertToUTF8(wc, int32(x))
-      var b = wc $ chunk
-      assert a == b
-      x = 0
 
-#RFC-2781 "UTF-16, an encoding of ISO 10646"
+  var wc: WideCString
+  unsafeNew(wc, 1024 * 4 + 2)
 
-var wc: WideCString
+  #U+0000 to U+D7FF
-unsafeNew(wc, 1024 * 4 + 2)
+  #skip the U+0000
+  wc.testCP(1, 0xD7FF)
 
-#U+0000 to U+D7FF
+  #U+E000 to U+FFFF
-#skip the U+0000
+  wc.testCP(0xE000, 0xFFFF)
-wc.testCP(1, 0xD7FF)
 
-#U+E000 to U+FFFF
+  #U+10000 to U+10FFFF
-wc.testCP(0xE000, 0xFFFF)
+  wc.testCP2(0x10000, 0x10FFFF)
 
-#U+10000 to U+10FFFF
+  #invalid UTF-16
-wc.testCP2(0x10000, 0x10FFFF)
+  const
+    b = "\xEF\xBF\xBD"
+    c = "\xEF\xBF\xBF"
 
-#invalid UTF-16
+  wc[0] = cast[Utf16Char](0xDC00)
-const 
+  wc[1] = Utf16Char(0)
-  b = "\xEF\xBF\xBD"
+  var a = $wc
-  c = "\xEF\xBF\xBF"
+  doAssert a == b
 
-wc[0] = cast[Utf16Char](0xDC00)
+  wc[0] = cast[Utf16Char](0xFFFF)
-wc[1] = Utf16Char(0)
+  wc[1] = cast[Utf16Char](0xDC00)
-var a = $wc
+  wc[2] = Utf16Char(0)
-assert a == b
+  a = $wc
+  doAssert a == c & b
 
-wc[0] = cast[Utf16Char](0xFFFF)
+  wc[0] = cast[Utf16Char](0xD800)
-wc[1] = cast[Utf16Char](0xDC00)
+  wc[1] = Utf16Char(0)
-wc[2] = Utf16Char(0)
+  a = $wc
-a = $wc
+  doAssert a == b
-assert a == c & b
 
-wc[0] = cast[Utf16Char](0xD800)
+  wc[0] = cast[Utf16Char](0xD800)
-wc[1] = Utf16Char(0)
+  wc[1] = cast[Utf16Char](0xFFFF)
-a = $wc
+  wc[2] = Utf16Char(0)
-assert a == b
+  a = $wc
+  doAssert a == b & c
 
-wc[0] = cast[Utf16Char](0xD800)
+  echo "OK"
-wc[1] = cast[Utf16Char](0xFFFF)
-wc[2] = Utf16Char(0)
-a = $wc
-assert a == b & c
-
-echo "OK"