summary refs log tree commit diff stats
path: root/tests/misc
diff options
context:
space:
mode:
Diffstat (limited to 'tests/misc')
-rw-r--r--tests/misc/tlastmod.nim8
-rw-r--r--tests/misc/tloops.nim2
-rw-r--r--tests/misc/tnot.nim6
-rw-r--r--tests/misc/tpos.nim6
-rw-r--r--tests/misc/tprep.nim4
-rw-r--r--tests/misc/tradix.nim20
-rw-r--r--tests/misc/treadln.nim4
-rw-r--r--tests/misc/tsimplesort.nim42
-rw-r--r--tests/misc/tvarnums.nim2
9 files changed, 45 insertions, 49 deletions
diff --git a/tests/misc/tlastmod.nim b/tests/misc/tlastmod.nim
index 75b047fc8..92ac922f7 100644
--- a/tests/misc/tlastmod.nim
+++ b/tests/misc/tlastmod.nim
@@ -6,13 +6,13 @@ import
 proc main() =

   var

     a, b: TTime

-  a = getLastModificationTime(ParamStr(1))

-  b = getLastModificationTime(ParamStr(2))

+  a = getLastModificationTime(paramStr(1))

+  b = getLastModificationTime(paramStr(2))

   writeln(stdout, $a)

   writeln(stdout, $b)

   if a < b:

-    Write(stdout, "$2 is newer than $1\n" % [ParamStr(1), ParamStr(2)])

+    write(stdout, "$2 is newer than $1\n" % [paramStr(1), paramStr(2)])

   else:

-    Write(stdout, "$1 is newer than $2\n" % [ParamStr(1), ParamStr(2)])

+    write(stdout, "$1 is newer than $2\n" % [paramStr(1), paramStr(2)])

 

 main()

diff --git a/tests/misc/tloops.nim b/tests/misc/tloops.nim
index f6f939769..1aada0298 100644
--- a/tests/misc/tloops.nim
+++ b/tests/misc/tloops.nim
@@ -31,7 +31,7 @@ proc TestLoops() =
       break
     break
 
-  while True:
+  while true:
     break
 
 
diff --git a/tests/misc/tnot.nim b/tests/misc/tnot.nim
index cd0f538e6..6193e21e1 100644
--- a/tests/misc/tnot.nim
+++ b/tests/misc/tnot.nim
@@ -5,16 +5,16 @@ discard """
 """
 # BUG: following compiles, but should not:
 
-proc nodeOfDegree(x: Int): bool = 
+proc nodeOfDegree(x: int): bool = 
   result = false
 
 proc main = 
   for j in 0..2:
     for i in 0..10:
       if not nodeOfDegree(1) >= 0: #ERROR_MSG type mismatch
-        Echo "Yes"
+        echo "Yes"
       else:
-        Echo "No"
+        echo "No"
 
 main()
 
diff --git a/tests/misc/tpos.nim b/tests/misc/tpos.nim
index 3d72536dd..5560ef050 100644
--- a/tests/misc/tpos.nim
+++ b/tests/misc/tpos.nim
@@ -14,10 +14,10 @@ proc mypos(sub, s: string, start: int = 0): int =
   if i >= N:

     result = -1

   else:

-    while True:

+    while true:

       if s[i] == sub[j]:

-        Inc(i)

-        Inc(j)

+        inc(i)

+        inc(j)

       else:

         i = i - j + 1

         j = 0

diff --git a/tests/misc/tprep.nim b/tests/misc/tprep.nim
index 4ef9e2543..8f40300d6 100644
--- a/tests/misc/tprep.nim
+++ b/tests/misc/tprep.nim
@@ -24,7 +24,7 @@ else:
 
 var
   s: string
-write(stdout, "compiled at " & system.compileDate &
-              " " & compileTime & "\n")
+write(stdout, "compiled at " & system.CompileDate &
+              " " & CompileTime & "\n")
 echo getDateStr()
 echo getClockStr()
diff --git a/tests/misc/tradix.nim b/tests/misc/tradix.nim
index e5998ee12..311aa9ccd 100644
--- a/tests/misc/tradix.nim
+++ b/tests/misc/tradix.nim
@@ -4,7 +4,7 @@
 ## We use a radix tree with node compression. 
 ## There are two node kinds:
 
-const bitsPerUnit = 8*sizeof(int)
+const BitsPerUnit = 8*sizeof(int)
 
 type
   TRadixNodeKind = enum rnLinear, rnFull, rnLeafBits, rnLeafLinear
@@ -42,13 +42,13 @@ proc testBit(w, i: int): bool {.inline.} =
   result = (w and (1 shl (i %% BitsPerUnit))) != 0
 
 proc setBit(w: var int, i: int) {.inline.} = 
-  w = w or (1 shl (i %% bitsPerUnit))
+  w = w or (1 shl (i %% BitsPerUnit))
 
 proc resetBit(w: var int, i: int) {.inline.} = 
-  w = w and not (1 shl (i %% bitsPerUnit))
+  w = w and not (1 shl (i %% BitsPerUnit))
 
 proc testOrSetBit(w: var int, i: int): bool {.inline.} = 
-  var x = (1 shl (i %% bitsPerUnit))
+  var x = (1 shl (i %% BitsPerUnit))
   if (w and x) != 0: return true
   w = w or x
 
@@ -78,7 +78,7 @@ proc exclLeaf(r: PRadixNode, a: int) =
         return
   else: assert(false)
 
-proc contains*(r: PRadixNode, a: TAddress): bool =
+proc contains*(r: PRadixNode, a: ByteAddress): bool =
   if r == nil: return false
   var x = searchInner(r, a shr 24 and 0xff)
   if x == nil: return false
@@ -88,7 +88,7 @@ proc contains*(r: PRadixNode, a: TAddress): bool =
   if x == nil: return false
   return searchLeaf(x, a and 0xff)
 
-proc excl*(r: PRadixNode, a: TAddress): bool =
+proc excl*(r: PRadixNode, a: ByteAddress): bool =
   if r == nil: return false
   var x = searchInner(r, a shr 24 and 0xff)
   if x == nil: return false
@@ -167,10 +167,10 @@ proc addInner(r: var PRadixNode, a: int, d: int): bool =
     return addInner(x.b[k], a, d-8)
   else: assert(false)
 
-proc incl*(r: var PRadixNode, a: TAddress) {.inline.} = 
+proc incl*(r: var PRadixNode, a: ByteAddress) {.inline.} = 
   discard addInner(r, a, 24)
   
-proc testOrIncl*(r: var PRadixNode, a: TAddress): bool {.inline.} = 
+proc testOrIncl*(r: var PRadixNode, a: ByteAddress): bool {.inline.} = 
   return addInner(r, a, 24)
       
 iterator innerElements(r: PRadixNode): tuple[prefix: int, n: PRadixNode] = 
@@ -204,7 +204,7 @@ iterator leafElements(r: PRadixNode): int =
         yield ze(r.keys[i])
     else: assert(false)
     
-iterator elements*(r: PRadixNode): TAddress {.inline.} = 
+iterator elements*(r: PRadixNode): ByteAddress {.inline.} = 
   for p1, n1 in innerElements(r): 
     for p2, n2 in innerElements(n1):
       for p3, n3 in innerElements(n2):
@@ -297,7 +297,7 @@ when false:
         result = ze(r.keys[i.x])
         inc(i.x)
 
-  iterator elements(r: PRadixNode): TAddress {.inline.} = 
+  iterator elements(r: PRadixNode): ByteAddress {.inline.} = 
     var
       a, b, c, d: TRadixIter
     init(a, r)
diff --git a/tests/misc/treadln.nim b/tests/misc/treadln.nim
index 1117ab5f9..1edbea992 100644
--- a/tests/misc/treadln.nim
+++ b/tests/misc/treadln.nim
@@ -2,11 +2,11 @@
 # Macintosh, Unix or Windows text format.
 
 var
-  inp: TFile
+  inp: File
   line: string
 
 if open(inp, "readme.txt"):
-  while not EndOfFile(inp):
+  while not endOfFile(inp):
     line = readLine(inp)
     echo("#" & line & "#")
   close(inp)
diff --git a/tests/misc/tsimplesort.nim b/tests/misc/tsimplesort.nim
index 0167ca78a..c282b3445 100644
--- a/tests/misc/tsimplesort.nim
+++ b/tests/misc/tsimplesort.nim
@@ -4,11 +4,7 @@ discard """
   
 import hashes, math
 
-
-when defined(shallowADT):
-  {.pragma: myShallow, shallow.}
-else:
-  {.pragma: myShallow.}
+{.pragma: myShallow.}
 
 type
   TSlotEnum = enum seEmpty, seFilled, seDeleted
@@ -63,7 +59,7 @@ template rawInsertImpl() =
   data[h].val = val
   data[h].slot = seFilled
 
-proc RawGet[A, B](t: TTable[A, B], key: A): int =
+proc rawGet[A, B](t: TTable[A, B], key: A): int =
   rawGetImpl()
 
 proc `[]`*[A, B](t: TTable[A, B], key: A): B =
@@ -71,31 +67,31 @@ proc `[]`*[A, B](t: TTable[A, B], key: A): B =
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
   ## exists.
-  var index = RawGet(t, key)
+  var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
 
 proc hasKey*[A, B](t: TTable[A, B], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = rawGet(t, key) >= 0
 
-proc RawInsert[A, B](t: var TTable[A, B], data: var TKeyValuePairSeq[A, B],
+proc rawInsert[A, B](t: var TTable[A, B], data: var TKeyValuePairSeq[A, B],
                      key: A, val: B) =
   rawInsertImpl()
 
-proc Enlarge[A, B](t: var TTable[A, B]) =
+proc enlarge[A, B](t: var TTable[A, B]) =
   var n: TKeyValuePairSeq[A, B]
   newSeq(n, len(t.data) * growthFactor)
   for i in countup(0, high(t.data)):
-    if t.data[i].slot == seFilled: RawInsert(t, n, t.data[i].key, t.data[i].val)
+    if t.data[i].slot == seFilled: rawInsert(t, n, t.data[i].key, t.data[i].val)
   swap(t.data, n)
 
-template PutImpl() =
-  var index = RawGet(t, key)
+template putImpl() =
+  var index = rawGet(t, key)
   if index >= 0:
     t.data[index].val = val
   else:
-    if mustRehash(len(t.data), t.counter): Enlarge(t)
-    RawInsert(t, t.data, key, val)
+    if mustRehash(len(t.data), t.counter): enlarge(t)
+    rawInsert(t, t.data, key, val)
     inc(t.counter)
 
 proc `[]=`*[A, B](t: var TTable[A, B], key: A, val: B) =
@@ -104,7 +100,7 @@ proc `[]=`*[A, B](t: var TTable[A, B], key: A, val: B) =
 
 proc del*[A, B](t: var TTable[A, B], key: A) =
   ## deletes `key` from hash table `t`.
-  var index = RawGet(t, key)
+  var index = rawGet(t, key)
   if index >= 0:
     t.data[index].slot = seDeleted
     dec(t.counter)
@@ -183,24 +179,24 @@ proc hasKey*[A](t: TCountTable[A], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = rawGet(t, key) >= 0
 
-proc RawInsert[A](t: TCountTable[A], data: var seq[tuple[key: A, val: int]],
+proc rawInsert[A](t: TCountTable[A], data: var seq[tuple[key: A, val: int]],
                   key: A, val: int) =
   var h: THash = hash(key) and high(data)
   while data[h].val != 0: h = nextTry(h, high(data))
   data[h].key = key
   data[h].val = val
 
-proc Enlarge[A](t: var TCountTable[A]) =
+proc enlarge[A](t: var TCountTable[A]) =
   var n: seq[tuple[key: A, val: int]]
   newSeq(n, len(t.data) * growthFactor)
   for i in countup(0, high(t.data)):
-    if t.data[i].val != 0: RawInsert(t, n, t.data[i].key, t.data[i].val)
+    if t.data[i].val != 0: rawInsert(t, n, t.data[i].key, t.data[i].val)
   swap(t.data, n)
 
 proc `[]=`*[A](t: var TCountTable[A], key: A, val: int) =
   ## puts a (key, value)-pair into `t`. `val` has to be positive.
   assert val > 0
-  PutImpl()
+  putImpl()
 
 proc initCountTable*[A](initialSize=64): TCountTable[A] =
   ## creates a new count table that is empty. `initialSize` needs to be
@@ -224,11 +220,11 @@ proc inc*[A](t: var TCountTable[A], key: A, val = 1) =
   if index >= 0:
     inc(t.data[index].val, val)
   else:
-    if mustRehash(len(t.data), t.counter): Enlarge(t)
-    RawInsert(t, t.data, key, val)
+    if mustRehash(len(t.data), t.counter): enlarge(t)
+    rawInsert(t, t.data, key, val)
     inc(t.counter)
 
-proc Smallest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+proc smallest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
   ## returns the largest (key,val)-pair. Efficiency: O(n)
   assert t.len > 0
   var minIdx = 0
@@ -237,7 +233,7 @@ proc Smallest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
   result.key = t.data[minIdx].key
   result.val = t.data[minIdx].val
 
-proc Largest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+proc largest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
   ## returns the (key,val)-pair with the largest `val`. Efficiency: O(n)
   assert t.len > 0
   var maxIdx = 0
diff --git a/tests/misc/tvarnums.nim b/tests/misc/tvarnums.nim
index 4f99df8b9..b880cf006 100644
--- a/tests/misc/tvarnums.nim
+++ b/tests/misc/tvarnums.nim
@@ -74,7 +74,7 @@ proc toNum(b: TBuffer): int32 =
   while (ze(b[i]) and 128) != 0:

     inc(i)

     result = result or ((int32(ze(b[i])) and 127'i32) shl Shift)

-    Shift = shift + 7'i32

+    Shift = Shift + 7'i32

   if (ze(b[0]) and (1 shl 6)) != 0: # sign bit set?

     result = (not result) +% 1'i32

     # this is the same as ``- result``
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-02-09 20:49:17 +0000