mirror of
https://github.com/golang/go
synced 2024-11-05 16:26:11 -07:00
635 lines
9.2 KiB
Go
635 lines
9.2 KiB
Go
// run
|
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Test integer division by constants.
|
|
|
|
package main
|
|
|
|
import "math/rand"
|
|
|
|
const Count = 1e5
|
|
|
|
func i64rand() int64 {
|
|
for {
|
|
a := int64(rand.Uint32())
|
|
a = (a << 32) | int64(rand.Uint32())
|
|
a >>= uint(rand.Intn(64))
|
|
if -a != a {
|
|
return a
|
|
}
|
|
}
|
|
return 0 // impossible
|
|
}
|
|
|
|
func i64test(a, b, c int64) {
|
|
d := a / c
|
|
if d != b {
|
|
println("i64", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func i64run() {
|
|
var a, b int64
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = i64rand()
|
|
|
|
b = a / 1
|
|
i64test(a, b, 1)
|
|
b = a / 2
|
|
i64test(a, b, 2)
|
|
b = a / 3
|
|
i64test(a, b, 3)
|
|
b = a / 4
|
|
i64test(a, b, 4)
|
|
b = a / 5
|
|
i64test(a, b, 5)
|
|
b = a / 6
|
|
i64test(a, b, 6)
|
|
b = a / 7
|
|
i64test(a, b, 7)
|
|
b = a / 8
|
|
i64test(a, b, 8)
|
|
b = a / 10
|
|
i64test(a, b, 10)
|
|
b = a / 16
|
|
i64test(a, b, 16)
|
|
b = a / 20
|
|
i64test(a, b, 20)
|
|
b = a / 32
|
|
i64test(a, b, 32)
|
|
b = a / 60
|
|
i64test(a, b, 60)
|
|
b = a / 64
|
|
i64test(a, b, 64)
|
|
b = a / 128
|
|
i64test(a, b, 128)
|
|
b = a / 256
|
|
i64test(a, b, 256)
|
|
b = a / 16384
|
|
i64test(a, b, 16384)
|
|
|
|
b = a / -1
|
|
i64test(a, b, -1)
|
|
b = a / -2
|
|
i64test(a, b, -2)
|
|
b = a / -3
|
|
i64test(a, b, -3)
|
|
b = a / -4
|
|
i64test(a, b, -4)
|
|
b = a / -5
|
|
i64test(a, b, -5)
|
|
b = a / -6
|
|
i64test(a, b, -6)
|
|
b = a / -7
|
|
i64test(a, b, -7)
|
|
b = a / -8
|
|
i64test(a, b, -8)
|
|
b = a / -10
|
|
i64test(a, b, -10)
|
|
b = a / -16
|
|
i64test(a, b, -16)
|
|
b = a / -20
|
|
i64test(a, b, -20)
|
|
b = a / -32
|
|
i64test(a, b, -32)
|
|
b = a / -60
|
|
i64test(a, b, -60)
|
|
b = a / -64
|
|
i64test(a, b, -64)
|
|
b = a / -128
|
|
i64test(a, b, -128)
|
|
b = a / -256
|
|
i64test(a, b, -256)
|
|
b = a / -16384
|
|
i64test(a, b, -16384)
|
|
}
|
|
}
|
|
|
|
func u64rand() uint64 {
|
|
a := uint64(rand.Uint32())
|
|
a = (a << 32) | uint64(rand.Uint32())
|
|
a >>= uint(rand.Intn(64))
|
|
return a
|
|
}
|
|
|
|
func u64test(a, b, c uint64) {
|
|
d := a / c
|
|
if d != b {
|
|
println("u64", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func u64run() {
|
|
var a, b uint64
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = u64rand()
|
|
|
|
b = a / 1
|
|
u64test(a, b, 1)
|
|
b = a / 2
|
|
u64test(a, b, 2)
|
|
b = a / 3
|
|
u64test(a, b, 3)
|
|
b = a / 4
|
|
u64test(a, b, 4)
|
|
b = a / 5
|
|
u64test(a, b, 5)
|
|
b = a / 6
|
|
u64test(a, b, 6)
|
|
b = a / 7
|
|
u64test(a, b, 7)
|
|
b = a / 8
|
|
u64test(a, b, 8)
|
|
b = a / 10
|
|
u64test(a, b, 10)
|
|
b = a / 16
|
|
u64test(a, b, 16)
|
|
b = a / 20
|
|
u64test(a, b, 20)
|
|
b = a / 32
|
|
u64test(a, b, 32)
|
|
b = a / 60
|
|
u64test(a, b, 60)
|
|
b = a / 64
|
|
u64test(a, b, 64)
|
|
b = a / 128
|
|
u64test(a, b, 128)
|
|
b = a / 256
|
|
u64test(a, b, 256)
|
|
b = a / 16384
|
|
u64test(a, b, 16384)
|
|
}
|
|
}
|
|
|
|
func i32rand() int32 {
|
|
for {
|
|
a := int32(rand.Uint32())
|
|
a >>= uint(rand.Intn(32))
|
|
if -a != a {
|
|
return a
|
|
}
|
|
}
|
|
return 0 // impossible
|
|
}
|
|
|
|
func i32test(a, b, c int32) {
|
|
d := a / c
|
|
if d != b {
|
|
println("i32", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func i32run() {
|
|
var a, b int32
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = i32rand()
|
|
|
|
b = a / 1
|
|
i32test(a, b, 1)
|
|
b = a / 2
|
|
i32test(a, b, 2)
|
|
b = a / 3
|
|
i32test(a, b, 3)
|
|
b = a / 4
|
|
i32test(a, b, 4)
|
|
b = a / 5
|
|
i32test(a, b, 5)
|
|
b = a / 6
|
|
i32test(a, b, 6)
|
|
b = a / 7
|
|
i32test(a, b, 7)
|
|
b = a / 8
|
|
i32test(a, b, 8)
|
|
b = a / 10
|
|
i32test(a, b, 10)
|
|
b = a / 16
|
|
i32test(a, b, 16)
|
|
b = a / 20
|
|
i32test(a, b, 20)
|
|
b = a / 32
|
|
i32test(a, b, 32)
|
|
b = a / 60
|
|
i32test(a, b, 60)
|
|
b = a / 64
|
|
i32test(a, b, 64)
|
|
b = a / 128
|
|
i32test(a, b, 128)
|
|
b = a / 256
|
|
i32test(a, b, 256)
|
|
b = a / 16384
|
|
i32test(a, b, 16384)
|
|
|
|
b = a / -1
|
|
i32test(a, b, -1)
|
|
b = a / -2
|
|
i32test(a, b, -2)
|
|
b = a / -3
|
|
i32test(a, b, -3)
|
|
b = a / -4
|
|
i32test(a, b, -4)
|
|
b = a / -5
|
|
i32test(a, b, -5)
|
|
b = a / -6
|
|
i32test(a, b, -6)
|
|
b = a / -7
|
|
i32test(a, b, -7)
|
|
b = a / -8
|
|
i32test(a, b, -8)
|
|
b = a / -10
|
|
i32test(a, b, -10)
|
|
b = a / -16
|
|
i32test(a, b, -16)
|
|
b = a / -20
|
|
i32test(a, b, -20)
|
|
b = a / -32
|
|
i32test(a, b, -32)
|
|
b = a / -60
|
|
i32test(a, b, -60)
|
|
b = a / -64
|
|
i32test(a, b, -64)
|
|
b = a / -128
|
|
i32test(a, b, -128)
|
|
b = a / -256
|
|
i32test(a, b, -256)
|
|
}
|
|
}
|
|
|
|
func u32rand() uint32 {
|
|
a := uint32(rand.Uint32())
|
|
a >>= uint(rand.Intn(32))
|
|
return a
|
|
}
|
|
|
|
func u32test(a, b, c uint32) {
|
|
d := a / c
|
|
if d != b {
|
|
println("u32", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func u32run() {
|
|
var a, b uint32
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = u32rand()
|
|
|
|
b = a / 1
|
|
u32test(a, b, 1)
|
|
b = a / 2
|
|
u32test(a, b, 2)
|
|
b = a / 3
|
|
u32test(a, b, 3)
|
|
b = a / 4
|
|
u32test(a, b, 4)
|
|
b = a / 5
|
|
u32test(a, b, 5)
|
|
b = a / 6
|
|
u32test(a, b, 6)
|
|
b = a / 7
|
|
u32test(a, b, 7)
|
|
b = a / 8
|
|
u32test(a, b, 8)
|
|
b = a / 10
|
|
u32test(a, b, 10)
|
|
b = a / 16
|
|
u32test(a, b, 16)
|
|
b = a / 20
|
|
u32test(a, b, 20)
|
|
b = a / 32
|
|
u32test(a, b, 32)
|
|
b = a / 60
|
|
u32test(a, b, 60)
|
|
b = a / 64
|
|
u32test(a, b, 64)
|
|
b = a / 128
|
|
u32test(a, b, 128)
|
|
b = a / 256
|
|
u32test(a, b, 256)
|
|
b = a / 16384
|
|
u32test(a, b, 16384)
|
|
}
|
|
}
|
|
|
|
func i16rand() int16 {
|
|
for {
|
|
a := int16(rand.Uint32())
|
|
a >>= uint(rand.Intn(16))
|
|
if -a != a {
|
|
return a
|
|
}
|
|
}
|
|
return 0 // impossible
|
|
}
|
|
|
|
func i16test(a, b, c int16) {
|
|
d := a / c
|
|
if d != b {
|
|
println("i16", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func i16run() {
|
|
var a, b int16
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = i16rand()
|
|
|
|
b = a / 1
|
|
i16test(a, b, 1)
|
|
b = a / 2
|
|
i16test(a, b, 2)
|
|
b = a / 3
|
|
i16test(a, b, 3)
|
|
b = a / 4
|
|
i16test(a, b, 4)
|
|
b = a / 5
|
|
i16test(a, b, 5)
|
|
b = a / 6
|
|
i16test(a, b, 6)
|
|
b = a / 7
|
|
i16test(a, b, 7)
|
|
b = a / 8
|
|
i16test(a, b, 8)
|
|
b = a / 10
|
|
i16test(a, b, 10)
|
|
b = a / 16
|
|
i16test(a, b, 16)
|
|
b = a / 20
|
|
i16test(a, b, 20)
|
|
b = a / 32
|
|
i16test(a, b, 32)
|
|
b = a / 60
|
|
i16test(a, b, 60)
|
|
b = a / 64
|
|
i16test(a, b, 64)
|
|
b = a / 128
|
|
i16test(a, b, 128)
|
|
b = a / 256
|
|
i16test(a, b, 256)
|
|
b = a / 16384
|
|
i16test(a, b, 16384)
|
|
|
|
b = a / -1
|
|
i16test(a, b, -1)
|
|
b = a / -2
|
|
i16test(a, b, -2)
|
|
b = a / -3
|
|
i16test(a, b, -3)
|
|
b = a / -4
|
|
i16test(a, b, -4)
|
|
b = a / -5
|
|
i16test(a, b, -5)
|
|
b = a / -6
|
|
i16test(a, b, -6)
|
|
b = a / -7
|
|
i16test(a, b, -7)
|
|
b = a / -8
|
|
i16test(a, b, -8)
|
|
b = a / -10
|
|
i16test(a, b, -10)
|
|
b = a / -16
|
|
i16test(a, b, -16)
|
|
b = a / -20
|
|
i16test(a, b, -20)
|
|
b = a / -32
|
|
i16test(a, b, -32)
|
|
b = a / -60
|
|
i16test(a, b, -60)
|
|
b = a / -64
|
|
i16test(a, b, -64)
|
|
b = a / -128
|
|
i16test(a, b, -128)
|
|
b = a / -256
|
|
i16test(a, b, -256)
|
|
b = a / -16384
|
|
i16test(a, b, -16384)
|
|
}
|
|
}
|
|
|
|
func u16rand() uint16 {
|
|
a := uint16(rand.Uint32())
|
|
a >>= uint(rand.Intn(16))
|
|
return a
|
|
}
|
|
|
|
func u16test(a, b, c uint16) {
|
|
d := a / c
|
|
if d != b {
|
|
println("u16", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func u16run() {
|
|
var a, b uint16
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = u16rand()
|
|
|
|
b = a / 1
|
|
u16test(a, b, 1)
|
|
b = a / 2
|
|
u16test(a, b, 2)
|
|
b = a / 3
|
|
u16test(a, b, 3)
|
|
b = a / 4
|
|
u16test(a, b, 4)
|
|
b = a / 5
|
|
u16test(a, b, 5)
|
|
b = a / 6
|
|
u16test(a, b, 6)
|
|
b = a / 7
|
|
u16test(a, b, 7)
|
|
b = a / 8
|
|
u16test(a, b, 8)
|
|
b = a / 10
|
|
u16test(a, b, 10)
|
|
b = a / 16
|
|
u16test(a, b, 16)
|
|
b = a / 20
|
|
u16test(a, b, 20)
|
|
b = a / 32
|
|
u16test(a, b, 32)
|
|
b = a / 60
|
|
u16test(a, b, 60)
|
|
b = a / 64
|
|
u16test(a, b, 64)
|
|
b = a / 128
|
|
u16test(a, b, 128)
|
|
b = a / 256
|
|
u16test(a, b, 256)
|
|
b = a / 16384
|
|
u16test(a, b, 16384)
|
|
}
|
|
}
|
|
|
|
func i8rand() int8 {
|
|
for {
|
|
a := int8(rand.Uint32())
|
|
a >>= uint(rand.Intn(8))
|
|
if -a != a {
|
|
return a
|
|
}
|
|
}
|
|
return 0 // impossible
|
|
}
|
|
|
|
func i8test(a, b, c int8) {
|
|
d := a / c
|
|
if d != b {
|
|
println("i8", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func i8run() {
|
|
var a, b int8
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = i8rand()
|
|
|
|
b = a / 1
|
|
i8test(a, b, 1)
|
|
b = a / 2
|
|
i8test(a, b, 2)
|
|
b = a / 3
|
|
i8test(a, b, 3)
|
|
b = a / 4
|
|
i8test(a, b, 4)
|
|
b = a / 5
|
|
i8test(a, b, 5)
|
|
b = a / 6
|
|
i8test(a, b, 6)
|
|
b = a / 7
|
|
i8test(a, b, 7)
|
|
b = a / 8
|
|
i8test(a, b, 8)
|
|
b = a / 10
|
|
i8test(a, b, 10)
|
|
b = a / 8
|
|
i8test(a, b, 8)
|
|
b = a / 20
|
|
i8test(a, b, 20)
|
|
b = a / 32
|
|
i8test(a, b, 32)
|
|
b = a / 60
|
|
i8test(a, b, 60)
|
|
b = a / 64
|
|
i8test(a, b, 64)
|
|
b = a / 127
|
|
i8test(a, b, 127)
|
|
|
|
b = a / -1
|
|
i8test(a, b, -1)
|
|
b = a / -2
|
|
i8test(a, b, -2)
|
|
b = a / -3
|
|
i8test(a, b, -3)
|
|
b = a / -4
|
|
i8test(a, b, -4)
|
|
b = a / -5
|
|
i8test(a, b, -5)
|
|
b = a / -6
|
|
i8test(a, b, -6)
|
|
b = a / -7
|
|
i8test(a, b, -7)
|
|
b = a / -8
|
|
i8test(a, b, -8)
|
|
b = a / -10
|
|
i8test(a, b, -10)
|
|
b = a / -8
|
|
i8test(a, b, -8)
|
|
b = a / -20
|
|
i8test(a, b, -20)
|
|
b = a / -32
|
|
i8test(a, b, -32)
|
|
b = a / -60
|
|
i8test(a, b, -60)
|
|
b = a / -64
|
|
i8test(a, b, -64)
|
|
b = a / -128
|
|
i8test(a, b, -128)
|
|
}
|
|
}
|
|
|
|
func u8rand() uint8 {
|
|
a := uint8(rand.Uint32())
|
|
a >>= uint(rand.Intn(8))
|
|
return a
|
|
}
|
|
|
|
func u8test(a, b, c uint8) {
|
|
d := a / c
|
|
if d != b {
|
|
println("u8", a, b, c, d)
|
|
panic("fail")
|
|
}
|
|
}
|
|
|
|
func u8run() {
|
|
var a, b uint8
|
|
|
|
for i := 0; i < Count; i++ {
|
|
a = u8rand()
|
|
|
|
b = a / 1
|
|
u8test(a, b, 1)
|
|
b = a / 2
|
|
u8test(a, b, 2)
|
|
b = a / 3
|
|
u8test(a, b, 3)
|
|
b = a / 4
|
|
u8test(a, b, 4)
|
|
b = a / 5
|
|
u8test(a, b, 5)
|
|
b = a / 6
|
|
u8test(a, b, 6)
|
|
b = a / 7
|
|
u8test(a, b, 7)
|
|
b = a / 8
|
|
u8test(a, b, 8)
|
|
b = a / 10
|
|
u8test(a, b, 10)
|
|
b = a / 8
|
|
u8test(a, b, 8)
|
|
b = a / 20
|
|
u8test(a, b, 20)
|
|
b = a / 32
|
|
u8test(a, b, 32)
|
|
b = a / 60
|
|
u8test(a, b, 60)
|
|
b = a / 64
|
|
u8test(a, b, 64)
|
|
b = a / 128
|
|
u8test(a, b, 128)
|
|
b = a / 184
|
|
u8test(a, b, 184)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
xtest()
|
|
i64run()
|
|
u64run()
|
|
i32run()
|
|
u32run()
|
|
i16run()
|
|
u16run()
|
|
i8run()
|
|
u8run()
|
|
}
|
|
|
|
func xtest() {
|
|
}
|