5 files changed, 343 insertions, 0 deletions
diff --git a/tests/assign/moverload_asgn2.nim b/tests/assign/moverload_asgn2.nim
new file mode 100644
index 000000000..cfea48cd1
--- /dev/null
+++ b/tests/assign/moverload_asgn2.nim
@@ -0,0 +1,14 @@
+discard """
+  matrix: "--mm:refc"
+"""
+
+type
+  Concrete* = object
+    a*, b*: string
+    rc*: int # refcount
+
+proc `=`(d: var Concrete; src: Concrete) =
+  shallowCopy(d.a, src.a)
+  shallowCopy(d.b, src.b)
+  dec d.rc
+  d.rc = src.rc + 1
diff --git a/tests/assign/tassign.nim b/tests/assign/tassign.nim
new file mode 100644
index 000000000..fdec04d22
--- /dev/null
+++ b/tests/assign/tassign.nim
@@ -0,0 +1,218 @@
+discard """
+  output:
+'''
+TEMP=C:\Programs\xyz\bin
+8 5 0 0
+pre test a:test b:1 c:2 haha:3
+assignment test a:test b:1 c:2 haha:3
+abc123
+'''
+"""
+
+#[
+Concrete '='
+Concrete '='
+Concrete '='
+Concrete '='
+Concrete '='
+GenericT[T] '=' int
+GenericT[T] '=' float
+GenericT[T] '=' float
+GenericT[T] '=' float
+GenericT[T] '=' string
+GenericT[T] '=' int8
+GenericT[T] '=' bool
+GenericT[T] '=' bool
+GenericT[T] '=' bool
+GenericT[T] '=' bool
+]#
+
+block tassign:
+# Test the assignment operator for complex types which need RTTI
+  type
+    TRec = object
+      x, y: int
+      s: string
+      seq: seq[string]
+      arr: seq[seq[array[0..3, string]]]
+    TRecSeq = seq[TRec]
+
+  proc test() =
+    var
+      a, b: TRec
+    a.x = 1
+    a.y = 2
+    a.s = "Hallo!"
+    a.seq = @["abc", "def", "ghi", "jkl"]
+    a.arr = @[]
+    setLen(a.arr, 4)
+    a.arr[0] = @[]
+    a.arr[1] = @[]
+
+    b = a # perform a deep copy here!
+    b.seq = @["xyz", "huch", "was", "soll"]
+    doAssert len(a.seq) == 4
+    doAssert a.seq[3] == "jkl"
+    doAssert len(b.seq) == 4
+    doAssert b.seq[3] == "soll"
+    doAssert b.y == 2
+
+  test()
+
+
+
+import strutils
+block tcopy:
+  proc main() =
+    const
+      example = r"TEMP=C:\Programs\xyz\bin"
+    var
+      a, b: string
+      p: int
+    p = find(example, "=")
+    a = substr(example, 0, p-1)
+    b = substr(example, p+1)
+    writeLine(stdout, a & '=' & b)
+
+  main()
+
+
+
+block tgenericassign:
+  type
+    TAny {.pure.} = object
+      value: pointer
+      rawType: pointer
+
+  proc newAny(value, rawType: pointer): TAny =
+    result.value = value
+    result.rawType = rawType
+
+  var name: cstring = "example"
+
+  var ret: seq[tuple[name: string, a: TAny]] = @[]
+  for i in 0 .. 8000:
+    var tup = ($name, newAny(nil, nil))
+    doAssert(tup[0] == "example")
+    ret.add(tup)
+    doAssert(ret[ret.len()-1][0] == "example")
+
+
+
+block tgenericassign_tuples:
+  var t, s: tuple[x: string, c: int]
+
+  proc ugh: seq[tuple[x: string, c: int]] =
+    result = @[("abc", 232)]
+
+  t = ugh()[0]
+  s = t
+  s = ugh()[0]
+
+  doAssert s[0] == "abc"
+  doAssert s[1] == 232
+
+
+
+block tobjasgn:
+  type
+    TSomeObj = object of RootObj
+      a, b: int
+    PSomeObj = ref object
+      a, b: int
+
+  var a = TSomeObj(a: 8)
+  var b = PSomeObj(a: 5)
+  echo a.a, " ", b.a, " ", a.b, " ", b.b
+
+  # bug #575
+
+  type
+    Something = object of RootObj
+      a: string
+      b, c: int32
+
+  type
+    Other = object of Something
+      haha: int
+
+  proc `$`(x: Other): string =
+    result = "a:" & x.a & " b:" & $x.b & " c:" & $x.c & " haha:" & $x.haha
+
+  var
+    t: Other
+
+  t.a = "test"
+  t.b = 1
+  t.c = 2
+  t.haha = 3
+
+  echo "pre test ", $t
+  var x = t
+  echo "assignment test ", x
+
+
+when false:
+  type
+    Concrete = object
+      a, b: string
+
+  proc `=`(d: var Concrete; src: Concrete) =
+    shallowCopy(d.a, src.a)
+    shallowCopy(d.b, src.b)
+    echo "Concrete '='"
+
+  var x, y: array[0..2, Concrete]
+  var cA, cB: Concrete
+
+  var cATup, cBTup: tuple[x: int, ha: Concrete]
+
+  x = y
+  cA = cB
+  cATup = cBTup
+
+  type
+    GenericT[T] = object
+      a, b: T
+
+  proc `=`[T](d: var GenericT[T]; src: GenericT[T]) =
+    shallowCopy(d.a, src.a)
+    shallowCopy(d.b, src.b)
+    echo "GenericT[T] '=' ", typeof(T).name
+
+  var ag: GenericT[int]
+  var bg: GenericT[int]
+
+  ag = bg
+
+  var xg, yg: array[0..2, GenericT[float]]
+  var cAg, cBg: GenericT[string]
+
+  var cATupg, cBTupg: tuple[x: int, ha: GenericT[int8]]
+
+  xg = yg
+  cAg = cBg
+  cATupg = cBTupg
+
+  var caSeqg, cbSeqg: seq[GenericT[bool]]
+  newSeq(cbSeqg, 4)
+  caSeqg = cbSeqg
+
+  when false:
+    type
+      Foo = object
+        case b: bool
+        of false: xx: GenericT[int]
+        of true: yy: bool
+
+    var
+      a, b: Foo
+    a = b
+
+block tgeneric_assign_varargs:
+  template fatal(msgs: varargs[string]) =
+    for msg in msgs:
+      stdout.write(msg)
+    stdout.write('\n')
+
+  fatal "abc", "123"
diff --git a/tests/assign/tobject_assign.nim b/tests/assign/tobject_assign.nim
new file mode 100644
index 000000000..8e39ead53
--- /dev/null
+++ b/tests/assign/tobject_assign.nim
@@ -0,0 +1,49 @@
+# bug #16706
+
+block: # reduced example
+  type
+    A = object of RootObj
+      a0: string
+    B = object
+      b0: seq[A]
+  var c = newSeq[A](2)
+  var d = B(b0: c)
+
+when true: # original example
+  import std/[options, tables, times]
+
+  type
+    Data* = object
+      shifts*: OrderedTable[int64, Shift]
+      balance*: float
+
+    Shift* = object
+      quoted*: bool
+      date*: DateTime
+      description*: string
+      start*: Option[DateTime]
+      finish*: Option[DateTime]
+      breakTime*: Option[Duration]
+      rate*: float
+      qty: Option[float]
+      id*: int64
+
+  let shift = Shift(
+    quoted: true,
+    date: parse("2000-01-01", "yyyy-MM-dd"),
+    description: "abcdef",
+    start: none(DateTime),
+    finish: none(DateTime),
+    breakTime: none(Duration),
+    rate: 462.11,
+    qty: some(10.0),
+    id: getTime().toUnix()
+  )
+
+  var shifts: OrderedTable[int64, Shift]
+  shifts[shift.id] = shift
+
+  discard Data(
+    shifts: shifts,
+    balance: 0.00
+  )
diff --git a/tests/assign/toverload_asgn2.nim b/tests/assign/toverload_asgn2.nim
new file mode 100644
index 000000000..1104be92b
--- /dev/null
+++ b/tests/assign/toverload_asgn2.nim
@@ -0,0 +1,23 @@
+discard """
+  output: '''i value 88
+2aa'''
+  disabled: "true"
+"""
+
+import moverload_asgn2
+
+proc passAround(i: int): Concrete =
+  echo "i value ", i
+  result = Concrete(a: "aa", b: "bb", rc: 0)
+
+proc main =
+  let
+    i = 88
+    v = passAround(i)
+    z = v.a
+  var
+    x: Concrete
+  x = v
+  echo x.rc, z # 2aa
+
+main()
diff --git a/tests/assign/tvariantasgn.nim b/tests/assign/tvariantasgn.nim
new file mode 100644
index 000000000..4c3c38ca5
--- /dev/null
+++ b/tests/assign/tvariantasgn.nim
@@ -0,0 +1,39 @@
+discard """
+  output: "came here"
+"""
+
+#BUG
+type
+  TAnyKind = enum
+    nkInt,
+    nkFloat,
+    nkString
+  TAny = object
+    case kind: TAnyKind
+    of nkInt: intVal: int
+    of nkFloat: floatVal: float
+    of nkString: strVal: string
+
+var s: TAny
+s = TAny(kind: nkString, strVal: "test")
+
+var nr: TAny
+s = TAny(kind: nkInt, intVal: 78)
+
+
+# s = nr # works
+nr = s # fails!
+echo "came here"
+
+block: # bug #12464
+  type
+    Foo = object
+      case isFunc: bool
+      of false: nil
+      of true:
+        fun: proc(): int
+
+  const i = Foo(isFunc: false)
+
+  let j = i
+  doAssert not j.isFunc