test/ken/divconst.go

   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 }