gcc/testsuite/go.test/test/ken/divmod.go

   1 // $G $D/$F.go && $L $F.$A && ./$A.out
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 package main
   8
   9 const (
  10         // example from the spec
  11         n1 = +5
  12         n2 = -5
  13         d1 = +3
  14         d2 = -3
  15
  16         q1 = +1
  17         q2 = -1
  18         q3 = -1
  19         q4 = +1
  20
  21         r1 = +2
  22         r2 = -2
  23         r3 = +2
  24         r4 = -2
  25 )
  26
  27 func main() {
  28         /* ideals */
  29         if n1/d1 != q1 || n1%d1 != r1 {
  30                 println("ideal-1", n1, d1, n1/d1, n1%d1)
  31                 panic("fail")
  32         }
  33         if n2/d1 != q2 || n2%d1 != r2 {
  34                 println("ideal-2", n2, d1, n2/d1, n2%d1)
  35                 panic("fail")
  36         }
  37         if n1/d2 != q3 || n1%d2 != r3 {
  38                 println("ideal-3", n1, d2, n1/d2, n1%d2)
  39                 panic("fail")
  40         }
  41         if n2/d2 != q4 || n2%d2 != r4 {
  42                 println("ideal-4", n2, d2, n2/d2, n2%d2)
  43                 panic("fail")
  44         }
  45
  46         /* int */
  47         var in1 int = +5
  48         var in2 int = -5
  49         var id1 int = +3
  50         var id2 int = -3
  51
  52         if in1/id1 != q1 || in1%id1 != r1 {
  53                 println("int-1", in1, id1, in1/id1, in1%id1)
  54                 panic("fail")
  55         }
  56         if in2/id1 != q2 || in2%id1 != r2 {
  57                 println("int-2", in2, id1, in2/id1, in2%id1)
  58                 panic("fail")
  59         }
  60         if in1/id2 != q3 || in1%id2 != r3 {
  61                 println("int-3", in1, id2, in1/id2, in1%id2)
  62                 panic("fail")
  63         }
  64         if in2/id2 != q4 || in2%id2 != r4 {
  65                 println("int-4", in2, id2, in2/id2, in2%id2)
  66                 panic("fail")
  67         }
  68
  69         /* int8 */
  70         var bn1 int8 = +5
  71         var bn2 int8 = -5
  72         var bd1 int8 = +3
  73         var bd2 int8 = -3
  74
  75         if bn1/bd1 != q1 || bn1%bd1 != r1 {
  76                 println("int8-1", bn1, bd1, bn1/bd1, bn1%bd1)
  77                 panic("fail")
  78         }
  79         if bn2/bd1 != q2 || bn2%bd1 != r2 {
  80                 println("int8-2", bn2, bd1, bn2/bd1, bn2%bd1)
  81                 panic("fail")
  82         }
  83         if bn1/bd2 != q3 || bn1%bd2 != r3 {
  84                 println("int8-3", bn1, bd2, bn1/bd2, bn1%bd2)
  85                 panic("fail")
  86         }
  87         if bn2/bd2 != q4 || bn2%bd2 != r4 {
  88                 println("int8-4", bn2, bd2, bn2/bd2, bn2%bd2)
  89                 panic("fail")
  90         }
  91
  92         /* int16 */
  93         var sn1 int16 = +5
  94         var sn2 int16 = -5
  95         var sd1 int16 = +3
  96         var sd2 int16 = -3
  97
  98         if sn1/sd1 != q1 || sn1%sd1 != r1 {
  99                 println("int16-1", sn1, sd1, sn1/sd1, sn1%sd1)
 100                 panic("fail")
 101         }
 102         if sn2/sd1 != q2 || sn2%sd1 != r2 {
 103                 println("int16-2", sn2, sd1, sn2/sd1, sn2%sd1)
 104                 panic("fail")
 105         }
 106         if sn1/sd2 != q3 || sn1%sd2 != r3 {
 107                 println("int16-3", sn1, sd2, sn1/sd2, sn1%sd2)
 108                 panic("fail")
 109         }
 110         if sn2/sd2 != q4 || sn2%sd2 != r4 {
 111                 println("int16-4", sn2, sd2, sn2/sd2, sn2%sd2)
 112                 panic("fail")
 113         }
 114
 115         /* int32 */
 116         var ln1 int32 = +5
 117         var ln2 int32 = -5
 118         var ld1 int32 = +3
 119         var ld2 int32 = -3
 120
 121         if ln1/ld1 != q1 || ln1%ld1 != r1 {
 122                 println("int32-1", ln1, ld1, ln1/ld1, ln1%ld1)
 123                 panic("fail")
 124         }
 125         if ln2/ld1 != q2 || ln2%ld1 != r2 {
 126                 println("int32-2", ln2, ld1, ln2/ld1, ln2%ld1)
 127                 panic("fail")
 128         }
 129         if ln1/ld2 != q3 || ln1%ld2 != r3 {
 130                 println("int32-3", ln1, ld2, ln1/ld2, ln1%ld2)
 131                 panic("fail")
 132         }
 133         if ln2/ld2 != q4 || ln2%ld2 != r4 {
 134                 println("int32-4", ln2, ld2, ln2/ld2, ln2%ld2)
 135                 panic("fail")
 136         }
 137
 138         /* int64 */
 139         var qn1 int64 = +5
 140         var qn2 int64 = -5
 141         var qd1 int64 = +3
 142         var qd2 int64 = -3
 143
 144         if qn1/qd1 != q1 || qn1%qd1 != r1 {
 145                 println("int64-1", qn1, qd1, qn1/qd1, qn1%qd1)
 146                 panic("fail")
 147         }
 148         if qn2/qd1 != q2 || qn2%qd1 != r2 {
 149                 println("int64-2", qn2, qd1, qn2/qd1, qn2%qd1)
 150                 panic("fail")
 151         }
 152         if qn1/qd2 != q3 || qn1%qd2 != r3 {
 153                 println("int64-3", qn1, qd2, qn1/qd2, qn1%qd2)
 154                 panic("fail")
 155         }
 156         if qn2/qd2 != q4 || qn2%qd2 != r4 {
 157                 println("int64-4", qn2, qd2, qn2/qd2, qn2%qd2)
 158                 panic("fail")
 159         }
 160
 161         if n1/qd1 != q1 || n1%qd1 != r1 {
 162                 println("mixed int64-1", n1, qd1, n1/qd1, n1%qd1)
 163                 panic("fail")
 164         }
 165         if n2/qd1 != q2 || n2%qd1 != r2 {
 166                 println("mixed int64-2", n2, qd1, n2/qd1, n2%qd1)
 167                 panic("fail")
 168         }
 169         if n1/qd2 != q3 || n1%qd2 != r3 {
 170                 println("mixed int64-3", n1, qd2, n1/qd2, n1%qd2)
 171                 panic("fail")
 172         }
 173         if n2/qd2 != q4 || n2%qd2 != r4 {
 174                 println("mixed int64-4", n2, qd2, n2/qd2, n2%qd2)
 175                 panic("fail")
 176         }
 177
 178         if qn1/d1 != q1 || qn1%d1 != r1 {
 179                 println("mixed int64-5", qn1, d1, qn1/d1, qn1%d1)
 180                 panic("fail")
 181         }
 182         if qn2/d1 != q2 || qn2%d1 != r2 {
 183                 println("mixed int64-6", qn2, d1, qn2/d1, qn2%d1)
 184                 panic("fail")
 185         }
 186         if qn1/d2 != q3 || qn1%d2 != r3 {
 187                 println("mixed int64-7", qn1, d2, qn1/d2, qn1%d2)
 188                 panic("fail")
 189         }
 190         if qn2/d2 != q4 || qn2%d2 != r4 {
 191                 println("mixed int64-8", qn2, d2, qn2/d2, qn2%d2)
 192                 panic("fail")
 193         }
 194
 195         /* uint */
 196         var uin1 uint = +5
 197         var uid1 uint = +3
 198
 199         if uin1/uid1 != q1 || uin1%uid1 != r1 {
 200                 println("uint", uin1, uid1, uin1/uid1, uin1%uid1)
 201                 panic("fail")
 202         }
 203
 204         /* uint8 */
 205         var ubn1 uint8 = +5
 206         var ubd1 uint8 = +3
 207
 208         if ubn1/ubd1 != q1 || ubn1%ubd1 != r1 {
 209                 println("uint8", ubn1, ubd1, ubn1/ubd1, ubn1%ubd1)
 210                 panic("fail")
 211         }
 212
 213         /* uint16 */
 214         var usn1 uint16 = +5
 215         var usd1 uint16 = +3
 216
 217         if usn1/usd1 != q1 || usn1%usd1 != r1 {
 218                 println("uint16", usn1, usd1, usn1/usd1, usn1%usd1)
 219                 panic("fail")
 220         }
 221
 222         /* uint32 */
 223         var uln1 uint32 = +5
 224         var uld1 uint32 = +3
 225
 226         if uln1/uld1 != q1 || uln1%uld1 != r1 {
 227                 println("uint32", uln1, uld1, uln1/uld1, uln1%uld1)
 228                 panic("fail")
 229         }
 230
 231         /* uint64 */
 232         var uqn1 uint64 = +5
 233         var uqd1 uint64 = +3
 234
 235         if uqn1/uqd1 != q1 || uqn1%uqd1 != r1 {
 236                 println("uint64", uqn1, uqd1, uqn1/uqd1, uqn1%uqd1)
 237                 panic("fail")
 238         }
 239         if n1/uqd1 != q1 || n1%uqd1 != r1 {
 240                 println("mixed uint64-1", n1, uqd1, n1/uqd1, n1%uqd1)
 241                 panic("fail")
 242         }
 243         if uqn1/d1 != q1 || uqn1%d1 != r1 {
 244                 println("mixed uint64-2", uqn1, d1, uqn1/d1, uqn1%d1)
 245                 panic("fail")
 246         }
 247 }