Home | History | Annotate | Download | only in ken 
      1 // run
      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 // Test integer division by constants.
      8 
      9 package main
     10 
     11 import "math/rand"
     12 
     13 const Count = 1e5
     14 
     15 func i64rand() int64 {
     16 	for {
     17 		a := int64(rand.Uint32())
     18 		a = (a << 32) | int64(rand.Uint32())
     19 		a >>= uint(rand.Intn(64))
     20 		if -a != a {
     21 			return a
     22 		}
     23 	}
     24 	return 0 // impossible
     25 }
     26 
     27 func i64test(a, b, c int64) {
     28 	d := a / c
     29 	if d != b {
     30 		println("i64", a, b, c, d)
     31 		panic("fail")
     32 	}
     33 }
     34 
     35 func i64run() {
     36 	var a, b int64
     37 
     38 	for i := 0; i < Count; i++ {
     39 		a = i64rand()
     40 
     41 		b = a / 1
     42 		i64test(a, b, 1)
     43 		b = a / 2
     44 		i64test(a, b, 2)
     45 		b = a / 3
     46 		i64test(a, b, 3)
     47 		b = a / 4
     48 		i64test(a, b, 4)
     49 		b = a / 5
     50 		i64test(a, b, 5)
     51 		b = a / 6
     52 		i64test(a, b, 6)
     53 		b = a / 7
     54 		i64test(a, b, 7)
     55 		b = a / 8
     56 		i64test(a, b, 8)
     57 		b = a / 10
     58 		i64test(a, b, 10)
     59 		b = a / 16
     60 		i64test(a, b, 16)
     61 		b = a / 20
     62 		i64test(a, b, 20)
     63 		b = a / 32
     64 		i64test(a, b, 32)
     65 		b = a / 60
     66 		i64test(a, b, 60)
     67 		b = a / 64
     68 		i64test(a, b, 64)
     69 		b = a / 128
     70 		i64test(a, b, 128)
     71 		b = a / 256
     72 		i64test(a, b, 256)
     73 		b = a / 16384
     74 		i64test(a, b, 16384)
     75 
     76 		b = a / -1
     77 		i64test(a, b, -1)
     78 		b = a / -2
     79 		i64test(a, b, -2)
     80 		b = a / -3
     81 		i64test(a, b, -3)
     82 		b = a / -4
     83 		i64test(a, b, -4)
     84 		b = a / -5
     85 		i64test(a, b, -5)
     86 		b = a / -6
     87 		i64test(a, b, -6)
     88 		b = a / -7
     89 		i64test(a, b, -7)
     90 		b = a / -8
     91 		i64test(a, b, -8)
     92 		b = a / -10
     93 		i64test(a, b, -10)
     94 		b = a / -16
     95 		i64test(a, b, -16)
     96 		b = a / -20
     97 		i64test(a, b, -20)
     98 		b = a / -32
     99 		i64test(a, b, -32)
    100 		b = a / -60
    101 		i64test(a, b, -60)
    102 		b = a / -64
    103 		i64test(a, b, -64)
    104 		b = a / -128
    105 		i64test(a, b, -128)
    106 		b = a / -256
    107 		i64test(a, b, -256)
    108 		b = a / -16384
    109 		i64test(a, b, -16384)
    110 	}
    111 }
    112 
    113 func u64rand() uint64 {
    114 	a := uint64(rand.Uint32())
    115 	a = (a << 32) | uint64(rand.Uint32())
    116 	a >>= uint(rand.Intn(64))
    117 	return a
    118 }
    119 
    120 func u64test(a, b, c uint64) {
    121 	d := a / c
    122 	if d != b {
    123 		println("u64", a, b, c, d)
    124 		panic("fail")
    125 	}
    126 }
    127 
    128 func u64run() {
    129 	var a, b uint64
    130 
    131 	for i := 0; i < Count; i++ {
    132 		a = u64rand()
    133 
    134 		b = a / 1
    135 		u64test(a, b, 1)
    136 		b = a / 2
    137 		u64test(a, b, 2)
    138 		b = a / 3
    139 		u64test(a, b, 3)
    140 		b = a / 4
    141 		u64test(a, b, 4)
    142 		b = a / 5
    143 		u64test(a, b, 5)
    144 		b = a / 6
    145 		u64test(a, b, 6)
    146 		b = a / 7
    147 		u64test(a, b, 7)
    148 		b = a / 8
    149 		u64test(a, b, 8)
    150 		b = a / 10
    151 		u64test(a, b, 10)
    152 		b = a / 16
    153 		u64test(a, b, 16)
    154 		b = a / 20
    155 		u64test(a, b, 20)
    156 		b = a / 32
    157 		u64test(a, b, 32)
    158 		b = a / 60
    159 		u64test(a, b, 60)
    160 		b = a / 64
    161 		u64test(a, b, 64)
    162 		b = a / 128
    163 		u64test(a, b, 128)
    164 		b = a / 256
    165 		u64test(a, b, 256)
    166 		b = a / 16384
    167 		u64test(a, b, 16384)
    168 	}
    169 }
    170 
    171 func i32rand() int32 {
    172 	for {
    173 		a := int32(rand.Uint32())
    174 		a >>= uint(rand.Intn(32))
    175 		if -a != a {
    176 			return a
    177 		}
    178 	}
    179 	return 0 // impossible
    180 }
    181 
    182 func i32test(a, b, c int32) {
    183 	d := a / c
    184 	if d != b {
    185 		println("i32", a, b, c, d)
    186 		panic("fail")
    187 	}
    188 }
    189 
    190 func i32run() {
    191 	var a, b int32
    192 
    193 	for i := 0; i < Count; i++ {
    194 		a = i32rand()
    195 
    196 		b = a / 1
    197 		i32test(a, b, 1)
    198 		b = a / 2
    199 		i32test(a, b, 2)
    200 		b = a / 3
    201 		i32test(a, b, 3)
    202 		b = a / 4
    203 		i32test(a, b, 4)
    204 		b = a / 5
    205 		i32test(a, b, 5)
    206 		b = a / 6
    207 		i32test(a, b, 6)
    208 		b = a / 7
    209 		i32test(a, b, 7)
    210 		b = a / 8
    211 		i32test(a, b, 8)
    212 		b = a / 10
    213 		i32test(a, b, 10)
    214 		b = a / 16
    215 		i32test(a, b, 16)
    216 		b = a / 20
    217 		i32test(a, b, 20)
    218 		b = a / 32
    219 		i32test(a, b, 32)
    220 		b = a / 60
    221 		i32test(a, b, 60)
    222 		b = a / 64
    223 		i32test(a, b, 64)
    224 		b = a / 128
    225 		i32test(a, b, 128)
    226 		b = a / 256
    227 		i32test(a, b, 256)
    228 		b = a / 16384
    229 		i32test(a, b, 16384)
    230 
    231 		b = a / -1
    232 		i32test(a, b, -1)
    233 		b = a / -2
    234 		i32test(a, b, -2)
    235 		b = a / -3
    236 		i32test(a, b, -3)
    237 		b = a / -4
    238 		i32test(a, b, -4)
    239 		b = a / -5
    240 		i32test(a, b, -5)
    241 		b = a / -6
    242 		i32test(a, b, -6)
    243 		b = a / -7
    244 		i32test(a, b, -7)
    245 		b = a / -8
    246 		i32test(a, b, -8)
    247 		b = a / -10
    248 		i32test(a, b, -10)
    249 		b = a / -16
    250 		i32test(a, b, -16)
    251 		b = a / -20
    252 		i32test(a, b, -20)
    253 		b = a / -32
    254 		i32test(a, b, -32)
    255 		b = a / -60
    256 		i32test(a, b, -60)
    257 		b = a / -64
    258 		i32test(a, b, -64)
    259 		b = a / -128
    260 		i32test(a, b, -128)
    261 		b = a / -256
    262 		i32test(a, b, -256)
    263 	}
    264 }
    265 
    266 func u32rand() uint32 {
    267 	a := uint32(rand.Uint32())
    268 	a >>= uint(rand.Intn(32))
    269 	return a
    270 }
    271 
    272 func u32test(a, b, c uint32) {
    273 	d := a / c
    274 	if d != b {
    275 		println("u32", a, b, c, d)
    276 		panic("fail")
    277 	}
    278 }
    279 
    280 func u32run() {
    281 	var a, b uint32
    282 
    283 	for i := 0; i < Count; i++ {
    284 		a = u32rand()
    285 
    286 		b = a / 1
    287 		u32test(a, b, 1)
    288 		b = a / 2
    289 		u32test(a, b, 2)
    290 		b = a / 3
    291 		u32test(a, b, 3)
    292 		b = a / 4
    293 		u32test(a, b, 4)
    294 		b = a / 5
    295 		u32test(a, b, 5)
    296 		b = a / 6
    297 		u32test(a, b, 6)
    298 		b = a / 7
    299 		u32test(a, b, 7)
    300 		b = a / 8
    301 		u32test(a, b, 8)
    302 		b = a / 10
    303 		u32test(a, b, 10)
    304 		b = a / 16
    305 		u32test(a, b, 16)
    306 		b = a / 20
    307 		u32test(a, b, 20)
    308 		b = a / 32
    309 		u32test(a, b, 32)
    310 		b = a / 60
    311 		u32test(a, b, 60)
    312 		b = a / 64
    313 		u32test(a, b, 64)
    314 		b = a / 128
    315 		u32test(a, b, 128)
    316 		b = a / 256
    317 		u32test(a, b, 256)
    318 		b = a / 16384
    319 		u32test(a, b, 16384)
    320 	}
    321 }
    322 
    323 func i16rand() int16 {
    324 	for {
    325 		a := int16(rand.Uint32())
    326 		a >>= uint(rand.Intn(16))
    327 		if -a != a {
    328 			return a
    329 		}
    330 	}
    331 	return 0 // impossible
    332 }
    333 
    334 func i16test(a, b, c int16) {
    335 	d := a / c
    336 	if d != b {
    337 		println("i16", a, b, c, d)
    338 		panic("fail")
    339 	}
    340 }
    341 
    342 func i16run() {
    343 	var a, b int16
    344 
    345 	for i := 0; i < Count; i++ {
    346 		a = i16rand()
    347 
    348 		b = a / 1
    349 		i16test(a, b, 1)
    350 		b = a / 2
    351 		i16test(a, b, 2)
    352 		b = a / 3
    353 		i16test(a, b, 3)
    354 		b = a / 4
    355 		i16test(a, b, 4)
    356 		b = a / 5
    357 		i16test(a, b, 5)
    358 		b = a / 6
    359 		i16test(a, b, 6)
    360 		b = a / 7
    361 		i16test(a, b, 7)
    362 		b = a / 8
    363 		i16test(a, b, 8)
    364 		b = a / 10
    365 		i16test(a, b, 10)
    366 		b = a / 16
    367 		i16test(a, b, 16)
    368 		b = a / 20
    369 		i16test(a, b, 20)
    370 		b = a / 32
    371 		i16test(a, b, 32)
    372 		b = a / 60
    373 		i16test(a, b, 60)
    374 		b = a / 64
    375 		i16test(a, b, 64)
    376 		b = a / 128
    377 		i16test(a, b, 128)
    378 		b = a / 256
    379 		i16test(a, b, 256)
    380 		b = a / 16384
    381 		i16test(a, b, 16384)
    382 
    383 		b = a / -1
    384 		i16test(a, b, -1)
    385 		b = a / -2
    386 		i16test(a, b, -2)
    387 		b = a / -3
    388 		i16test(a, b, -3)
    389 		b = a / -4
    390 		i16test(a, b, -4)
    391 		b = a / -5
    392 		i16test(a, b, -5)
    393 		b = a / -6
    394 		i16test(a, b, -6)
    395 		b = a / -7
    396 		i16test(a, b, -7)
    397 		b = a / -8
    398 		i16test(a, b, -8)
    399 		b = a / -10
    400 		i16test(a, b, -10)
    401 		b = a / -16
    402 		i16test(a, b, -16)
    403 		b = a / -20
    404 		i16test(a, b, -20)
    405 		b = a / -32
    406 		i16test(a, b, -32)
    407 		b = a / -60
    408 		i16test(a, b, -60)
    409 		b = a / -64
    410 		i16test(a, b, -64)
    411 		b = a / -128
    412 		i16test(a, b, -128)
    413 		b = a / -256
    414 		i16test(a, b, -256)
    415 		b = a / -16384
    416 		i16test(a, b, -16384)
    417 	}
    418 }
    419 
    420 func u16rand() uint16 {
    421 	a := uint16(rand.Uint32())
    422 	a >>= uint(rand.Intn(16))
    423 	return a
    424 }
    425 
    426 func u16test(a, b, c uint16) {
    427 	d := a / c
    428 	if d != b {
    429 		println("u16", a, b, c, d)
    430 		panic("fail")
    431 	}
    432 }
    433 
    434 func u16run() {
    435 	var a, b uint16
    436 
    437 	for i := 0; i < Count; i++ {
    438 		a = u16rand()
    439 
    440 		b = a / 1
    441 		u16test(a, b, 1)
    442 		b = a / 2
    443 		u16test(a, b, 2)
    444 		b = a / 3
    445 		u16test(a, b, 3)
    446 		b = a / 4
    447 		u16test(a, b, 4)
    448 		b = a / 5
    449 		u16test(a, b, 5)
    450 		b = a / 6
    451 		u16test(a, b, 6)
    452 		b = a / 7
    453 		u16test(a, b, 7)
    454 		b = a / 8
    455 		u16test(a, b, 8)
    456 		b = a / 10
    457 		u16test(a, b, 10)
    458 		b = a / 16
    459 		u16test(a, b, 16)
    460 		b = a / 20
    461 		u16test(a, b, 20)
    462 		b = a / 32
    463 		u16test(a, b, 32)
    464 		b = a / 60
    465 		u16test(a, b, 60)
    466 		b = a / 64
    467 		u16test(a, b, 64)
    468 		b = a / 128
    469 		u16test(a, b, 128)
    470 		b = a / 256
    471 		u16test(a, b, 256)
    472 		b = a / 16384
    473 		u16test(a, b, 16384)
    474 	}
    475 }
    476 
    477 func i8rand() int8 {
    478 	for {
    479 		a := int8(rand.Uint32())
    480 		a >>= uint(rand.Intn(8))
    481 		if -a != a {
    482 			return a
    483 		}
    484 	}
    485 	return 0 // impossible
    486 }
    487 
    488 func i8test(a, b, c int8) {
    489 	d := a / c
    490 	if d != b {
    491 		println("i8", a, b, c, d)
    492 		panic("fail")
    493 	}
    494 }
    495 
    496 func i8run() {
    497 	var a, b int8
    498 
    499 	for i := 0; i < Count; i++ {
    500 		a = i8rand()
    501 
    502 		b = a / 1
    503 		i8test(a, b, 1)
    504 		b = a / 2
    505 		i8test(a, b, 2)
    506 		b = a / 3
    507 		i8test(a, b, 3)
    508 		b = a / 4
    509 		i8test(a, b, 4)
    510 		b = a / 5
    511 		i8test(a, b, 5)
    512 		b = a / 6
    513 		i8test(a, b, 6)
    514 		b = a / 7
    515 		i8test(a, b, 7)
    516 		b = a / 8
    517 		i8test(a, b, 8)
    518 		b = a / 10
    519 		i8test(a, b, 10)
    520 		b = a / 8
    521 		i8test(a, b, 8)
    522 		b = a / 20
    523 		i8test(a, b, 20)
    524 		b = a / 32
    525 		i8test(a, b, 32)
    526 		b = a / 60
    527 		i8test(a, b, 60)
    528 		b = a / 64
    529 		i8test(a, b, 64)
    530 		b = a / 127
    531 		i8test(a, b, 127)
    532 
    533 		b = a / -1
    534 		i8test(a, b, -1)
    535 		b = a / -2
    536 		i8test(a, b, -2)
    537 		b = a / -3
    538 		i8test(a, b, -3)
    539 		b = a / -4
    540 		i8test(a, b, -4)
    541 		b = a / -5
    542 		i8test(a, b, -5)
    543 		b = a / -6
    544 		i8test(a, b, -6)
    545 		b = a / -7
    546 		i8test(a, b, -7)
    547 		b = a / -8
    548 		i8test(a, b, -8)
    549 		b = a / -10
    550 		i8test(a, b, -10)
    551 		b = a / -8
    552 		i8test(a, b, -8)
    553 		b = a / -20
    554 		i8test(a, b, -20)
    555 		b = a / -32
    556 		i8test(a, b, -32)
    557 		b = a / -60
    558 		i8test(a, b, -60)
    559 		b = a / -64
    560 		i8test(a, b, -64)
    561 		b = a / -128
    562 		i8test(a, b, -128)
    563 	}
    564 }
    565 
    566 func u8rand() uint8 {
    567 	a := uint8(rand.Uint32())
    568 	a >>= uint(rand.Intn(8))
    569 	return a
    570 }
    571 
    572 func u8test(a, b, c uint8) {
    573 	d := a / c
    574 	if d != b {
    575 		println("u8", a, b, c, d)
    576 		panic("fail")
    577 	}
    578 }
    579 
    580 func u8run() {
    581 	var a, b uint8
    582 
    583 	for i := 0; i < Count; i++ {
    584 		a = u8rand()
    585 
    586 		b = a / 1
    587 		u8test(a, b, 1)
    588 		b = a / 2
    589 		u8test(a, b, 2)
    590 		b = a / 3
    591 		u8test(a, b, 3)
    592 		b = a / 4
    593 		u8test(a, b, 4)
    594 		b = a / 5
    595 		u8test(a, b, 5)
    596 		b = a / 6
    597 		u8test(a, b, 6)
    598 		b = a / 7
    599 		u8test(a, b, 7)
    600 		b = a / 8
    601 		u8test(a, b, 8)
    602 		b = a / 10
    603 		u8test(a, b, 10)
    604 		b = a / 8
    605 		u8test(a, b, 8)
    606 		b = a / 20
    607 		u8test(a, b, 20)
    608 		b = a / 32
    609 		u8test(a, b, 32)
    610 		b = a / 60
    611 		u8test(a, b, 60)
    612 		b = a / 64
    613 		u8test(a, b, 64)
    614 		b = a / 128
    615 		u8test(a, b, 128)
    616 		b = a / 184
    617 		u8test(a, b, 184)
    618 	}
    619 }
    620 
    621 func main() {
    622 	xtest()
    623 	i64run()
    624 	u64run()
    625 	i32run()
    626 	u32run()
    627 	i16run()
    628 	u16run()
    629 	i8run()
    630 	u8run()
    631 }
    632 
    633 func xtest() {
    634 }
    635