Source file test/const.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 simple boolean and numeric constants.
     8  
     9  package main
    10  
    11  import "os"
    12  
    13  const (
    14  	c0      = 0
    15  	cm1     = -1
    16  	chuge   = 1 << 100
    17  	chuge_1 = chuge - 1
    18  	c1      = chuge >> 100
    19  	c3div2  = 3 / 2
    20  	c1e3    = 1e3
    21  
    22  	rsh1 = 1e100 >> 1000
    23  	rsh2 = 1e302 >> 1000
    24  
    25  	ctrue  = true
    26  	cfalse = !ctrue
    27  
    28  	// Issue #34563
    29  	_ = string(int(123))
    30  	_ = string(rune(456))
    31  )
    32  
    33  const (
    34  	f0              = 0.0
    35  	fm1             = -1.
    36  	fhuge   float64 = 1 << 100
    37  	fhuge_1 float64 = chuge - 1
    38  	f1      float64 = chuge >> 100
    39  	f3div2          = 3. / 2.
    40  	f1e3    float64 = 1e3
    41  )
    42  
    43  func assert(t bool, s string) {
    44  	if !t {
    45  		panic(s)
    46  	}
    47  }
    48  
    49  func ints() {
    50  	assert(c0 == 0, "c0")
    51  	assert(c1 == 1, "c1")
    52  	assert(chuge > chuge_1, "chuge")
    53  	assert(chuge_1+1 == chuge, "chuge 1")
    54  	assert(chuge+cm1+1 == chuge, "cm1")
    55  	assert(c3div2 == 1, "3/2")
    56  	assert(c1e3 == 1000, "c1e3 int")
    57  	assert(c1e3 == 1e3, "c1e3 float")
    58  	assert(rsh1 == 0, "rsh1")
    59  	assert(rsh2 == 9, "rsh2")
    60  
    61  	// verify that all (in range) are assignable as ints
    62  	var i int
    63  	i = c0
    64  	assert(i == c0, "i == c0")
    65  	i = cm1
    66  	assert(i == cm1, "i == cm1")
    67  	i = c1
    68  	assert(i == c1, "i == c1")
    69  	i = c3div2
    70  	assert(i == c3div2, "i == c3div2")
    71  	i = c1e3
    72  	assert(i == c1e3, "i == c1e3")
    73  
    74  	// verify that all are assignable as floats
    75  	var f float64
    76  	f = c0
    77  	assert(f == c0, "f == c0")
    78  	f = cm1
    79  	assert(f == cm1, "f == cm1")
    80  	f = chuge
    81  	assert(f == chuge, "f == chuge")
    82  	f = chuge_1
    83  	assert(f == chuge_1, "f == chuge_1")
    84  	f = c1
    85  	assert(f == c1, "f == c1")
    86  	f = c3div2
    87  	assert(f == c3div2, "f == c3div2")
    88  	f = c1e3
    89  	assert(f == c1e3, "f == c1e3")
    90  }
    91  
    92  func floats() {
    93  	assert(f0 == c0, "f0")
    94  	assert(f1 == c1, "f1")
    95  	// TODO(gri): exp/ssa/interp constant folding is incorrect.
    96  	if os.Getenv("GOSSAINTERP") == "" {
    97  		assert(fhuge == fhuge_1, "fhuge") // float64 can't distinguish fhuge, fhuge_1.
    98  	}
    99  	assert(fhuge_1+1 == fhuge, "fhuge 1")
   100  	assert(fhuge+fm1+1 == fhuge, "fm1")
   101  	assert(f3div2 == 1.5, "3./2.")
   102  	assert(f1e3 == 1000, "f1e3 int")
   103  	assert(f1e3 == 1.e3, "f1e3 float")
   104  
   105  	// verify that all (in range) are assignable as ints
   106  	var i int
   107  	i = f0
   108  	assert(i == f0, "i == f0")
   109  	i = fm1
   110  	assert(i == fm1, "i == fm1")
   111  
   112  	// verify that all are assignable as floats
   113  	var f float64
   114  	f = f0
   115  	assert(f == f0, "f == f0")
   116  	f = fm1
   117  	assert(f == fm1, "f == fm1")
   118  	f = fhuge
   119  	assert(f == fhuge, "f == fhuge")
   120  	f = fhuge_1
   121  	assert(f == fhuge_1, "f == fhuge_1")
   122  	f = f1
   123  	assert(f == f1, "f == f1")
   124  	f = f3div2
   125  	assert(f == f3div2, "f == f3div2")
   126  	f = f1e3
   127  	assert(f == f1e3, "f == f1e3")
   128  }
   129  
   130  func interfaces() {
   131  	var (
   132  		nilN interface{}
   133  		nilI *int
   134  		five = 5
   135  
   136  		_ = nil == interface{}(nil)
   137  		_ = interface{}(nil) == nil
   138  	)
   139  	ii := func(i1 interface{}, i2 interface{}) bool { return i1 == i2 }
   140  	ni := func(n interface{}, i int) bool { return n == i }
   141  	in := func(i int, n interface{}) bool { return i == n }
   142  	pi := func(p *int, i interface{}) bool { return p == i }
   143  	ip := func(i interface{}, p *int) bool { return i == p }
   144  
   145  	assert((interface{}(nil) == interface{}(nil)) == ii(nilN, nilN),
   146  		"for interface{}==interface{} compiler == runtime")
   147  
   148  	assert(((*int)(nil) == interface{}(nil)) == pi(nilI, nilN),
   149  		"for *int==interface{} compiler == runtime")
   150  	assert((interface{}(nil) == (*int)(nil)) == ip(nilN, nilI),
   151  		"for interface{}==*int compiler == runtime")
   152  
   153  	assert((&five == interface{}(nil)) == pi(&five, nilN),
   154  		"for interface{}==*int compiler == runtime")
   155  	assert((interface{}(nil) == &five) == ip(nilN, &five),
   156  		"for interface{}==*int compiler == runtime")
   157  
   158  	assert((5 == interface{}(5)) == ni(five, five),
   159  		"for int==interface{} compiler == runtime")
   160  	assert((interface{}(5) == 5) == in(five, five),
   161  		"for interface{}==int comipiler == runtime")
   162  }
   163  
   164  // Test that typed floating-point and complex arithmetic
   165  // is computed with correct precision.
   166  func truncate() {
   167  	const (
   168  		x30 = 1 << 30
   169  		x60 = 1 << 60
   170  
   171  		staticF32 = float32(x30) + 1 - x30
   172  		staticF64 = float64(x60) + 1 - x60
   173  		staticC64 = complex64(x30) + 1 - x30
   174  		staticC128 = complex128(x60) + 1 - x60
   175  	)
   176  	dynamicF32 := float32(x30)
   177  	dynamicF32 += 1
   178  	dynamicF32 -= x30
   179  
   180  	dynamicF64 := float64(x60)
   181  	dynamicF64 += 1
   182  	dynamicF64 -= x60
   183  
   184  	dynamicC64 := complex64(x30)
   185  	dynamicC64 += 1
   186  	dynamicC64 -= x30
   187  
   188  	dynamicC128 := complex128(x60)
   189  	dynamicC128 += 1
   190  	dynamicC128 -= x60
   191  
   192  	assert(staticF32 == 0, "staticF32 == 0")
   193  	assert(staticF64 == 0, "staticF64 == 0")
   194  	assert(dynamicF32 == 0, "dynamicF32 == 0")
   195  	assert(dynamicF64 == 0, "dynamicF64 == 0")
   196  	assert(staticC64 == 0, "staticC64 == 0")
   197  	assert(staticC128 == 0, "staticC128 == 0")
   198  	assert(dynamicC64 == 0, "dynamicC64 == 0")
   199  	assert(dynamicC128 == 0, "dynamicC128 == 0")
   200  }
   201  
   202  func main() {
   203  	ints()
   204  	floats()
   205  	interfaces()
   206  	truncate()
   207  
   208  	assert(ctrue == true, "ctrue == true")
   209  	assert(cfalse == false, "cfalse == false")
   210  }
   211  

View as plain text