Nim/tests/macros/tnewlit.nim at devel · googol-lab/Nim

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

import macros

type

MyType = object

a : int

b : string

macro test_newLit_MyType: untyped =

let mt = MyType(a: 123, b:"foobar")

result = newLit(mt)

doAssert test_newLit_MyType == MyType(a: 123, b:"foobar")

macro test_newLit_array: untyped =

let arr = [1,2,3,4,5]

result = newLit(arr)

doAssert test_newLit_array == [1,2,3,4,5]

macro test_newLit_seq_int: untyped =

let s: seq[int] = @[1,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[int] = test_newLit_seq_int

doAssert tmp == @[1,2,3,4,5]

macro test_newLit_seq_int8: untyped =

let s: seq[int8] = @[1'i8,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[int8] = test_newLit_seq_int8

doAssert tmp == @[1'i8,2,3,4,5]

macro test_newLit_seq_int16: untyped =

let s: seq[int16] = @[1'i16,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[int16] = test_newLit_seq_int16

doAssert tmp == @[1'i16,2,3,4,5]

macro test_newLit_seq_int32: untyped =

let s: seq[int32] = @[1'i32,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[int32] = test_newLit_seq_int32

doAssert tmp == @[1'i32,2,3,4,5]

macro test_newLit_seq_int64: untyped =

let s: seq[int64] = @[1'i64,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[int64] = test_newLit_seq_int64

doAssert tmp == @[1'i64,2,3,4,5]

macro test_newLit_seq_uint: untyped =

let s: seq[uint] = @[1u,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[uint] = test_newLit_seq_uint

doAssert tmp == @[1u,2,3,4,5]

macro test_newLit_seq_uint8: untyped =

let s: seq[uint8] = @[1'u8,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[uint8] = test_newLit_seq_uint8

doAssert tmp == @[1'u8,2,3,4,5]

macro test_newLit_seq_uint16: untyped =

let s: seq[uint16] = @[1'u16,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[uint16] = test_newLit_seq_uint16

doAssert tmp == @[1'u16,2,3,4,5]

macro test_newLit_seq_uint32: untyped =

let s: seq[uint32] = @[1'u32,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[uint32] = test_newLit_seq_uint32

doAssert tmp == @[1'u32,2,3,4,5]

macro test_newLit_seq_uint64: untyped =

let s: seq[uint64] = @[1'u64,2,3,4,5]

result = newLit(s)

block:

let tmp: seq[uint64] = test_newLit_seq_uint64

doAssert tmp == @[1'u64,2,3,4,5]

macro test_newLit_seq_float: untyped =

let s: seq[float] = @[1.0, 2,3,4,5]

result = newLit(s)

block:

let tmp: seq[float] = test_newLit_seq_float

doAssert tmp == @[1.0, 2,3,4,5]

macro test_newLit_seq_float32: untyped =

let s: seq[float32] = @[1.0'f32, 2,3,4,5]

result = newLit(s)

block:

let tmp: seq[float32] = test_newLit_seq_float32

doAssert tmp == @[1.0'f32, 2,3,4,5]

macro test_newLit_seq_float64: untyped =

let s: seq[float64] = @[1.0'f64, 2,3,4,5]

result = newLit(s)

block:

let tmp: seq[float64] = test_newLit_seq_float64

doAssert tmp == @[1.0'f64, 2,3,4,5]

macro test_newLit_tuple: untyped =

let tup: tuple[a:int,b:string] = (a: 123, b: "223")

result = newLit(tup)

doAssert test_newLit_tuple == (a: 123, b: "223")

type

ComposedType = object

mt: MyType

arr: array[4,int]

data: seq[byte]

macro test_newLit_ComposedType: untyped =

let ct = ComposedType(mt: MyType(a: 123, b:"abc"), arr: [1,2,3,4], data: @[1.byte, 3, 7, 127])

result = newLit(ct)

doAssert test_newLit_ComposedType == ComposedType(mt: MyType(a: 123, b:"abc"), arr: [1,2,3,4], data: @[1.byte, 3, 7, 127])

macro test_newLit_empty_seq_string: untyped =

var strSeq = newSeq[string](0)

result = newLit(strSeq)

block:

# x needs to be of type seq[string]

var x = test_newLit_empty_seq_string

x.add("xyz")

type

MyEnum = enum

meA

meB

macro test_newLit_Enum: untyped =

result = newLit(meA)

block:

let tmp: MyEnum = meA

doAssert tmp == test_newLit_Enum

macro test_newLit_set: untyped =

let myset = {MyEnum.low .. MyEnum.high}

result = newLit(myset)

block:

let tmp: set[MyEnum] = {MyEnum.low .. MyEnum.high}

doAssert tmp == test_newLit_set

FilesExpand file tree

tnewlit.nim

Latest commit

History

tnewlit.nim

File metadata and controls