...
Run Format

Source file test/nil.go

Documentation: test

     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 nil.
     8  
     9  package main
    10  
    11  import (
    12  	"fmt"
    13  	"time"
    14  )
    15  
    16  type T struct {
    17  	i int
    18  }
    19  
    20  type IN interface{}
    21  
    22  func main() {
    23  	var i *int
    24  	var f *float32
    25  	var s *string
    26  	var m map[float32]*int
    27  	var c chan int
    28  	var t *T
    29  	var in IN
    30  	var ta []IN
    31  
    32  	i = nil
    33  	f = nil
    34  	s = nil
    35  	m = nil
    36  	c = nil
    37  	t = nil
    38  	i = nil
    39  	ta = make([]IN, 1)
    40  	ta[0] = nil
    41  
    42  	_, _, _, _, _, _, _, _ = i, f, s, m, c, t, in, ta
    43  
    44  	arraytest()
    45  	chantest()
    46  	maptest()
    47  	slicetest()
    48  }
    49  
    50  func shouldPanic(f func()) {
    51  	defer func() {
    52  		if recover() == nil {
    53  			panic("not panicking")
    54  		}
    55  	}()
    56  	f()
    57  }
    58  
    59  func shouldBlock(f func()) {
    60  	go func() {
    61  		f()
    62  		panic("did not block")
    63  	}()
    64  	time.Sleep(1e7)
    65  }
    66  
    67  // nil array pointer
    68  
    69  func arraytest() {
    70  	var p *[10]int
    71  
    72  	// Looping over indices is fine.
    73  	s := 0
    74  	for i := range p {
    75  		s += i
    76  	}
    77  	if s != 45 {
    78  		panic(s)
    79  	}
    80  
    81  	s = 0
    82  	for i := 0; i < len(p); i++ {
    83  		s += i
    84  	}
    85  	if s != 45 {
    86  		panic(s)
    87  	}
    88  
    89  	// Looping over values is not.
    90  	shouldPanic(func() {
    91  		for i, v := range p {
    92  			s += i + v
    93  		}
    94  	})
    95  
    96  	shouldPanic(func() {
    97  		for i := 0; i < len(p); i++ {
    98  			s += p[i]
    99  		}
   100  	})
   101  }
   102  
   103  // nil channel
   104  // select tests already handle select on nil channel
   105  
   106  func chantest() {
   107  	var ch chan int
   108  
   109  	// nil channel is never ready
   110  	shouldBlock(func() {
   111  		ch <- 1
   112  	})
   113  	shouldBlock(func() {
   114  		<-ch
   115  	})
   116  	shouldBlock(func() {
   117  		x, ok := <-ch
   118  		println(x, ok) // unreachable
   119  	})
   120  
   121  	if len(ch) != 0 {
   122  		panic(len(ch))
   123  	}
   124  	if cap(ch) != 0 {
   125  		panic(cap(ch))
   126  	}
   127  }
   128  
   129  // nil map
   130  
   131  func maptest() {
   132  	var m map[int]int
   133  
   134  	// nil map appears empty
   135  	if len(m) != 0 {
   136  		panic(len(m))
   137  	}
   138  	if m[1] != 0 {
   139  		panic(m[1])
   140  	}
   141  	if x, ok := m[1]; x != 0 || ok {
   142  		panic(fmt.Sprint(x, ok))
   143  	}
   144  
   145  	for k, v := range m {
   146  		panic(k)
   147  		panic(v)
   148  	}
   149  
   150  	// can delete (non-existent) entries
   151  	delete(m, 2)
   152  
   153  	// but cannot be written to
   154  	shouldPanic(func() {
   155  		m[2] = 3
   156  	})
   157  }
   158  
   159  // nil slice
   160  
   161  func slicetest() {
   162  	var x []int
   163  
   164  	// nil slice is just a 0-element slice.
   165  	if len(x) != 0 {
   166  		panic(len(x))
   167  	}
   168  	if cap(x) != 0 {
   169  		panic(cap(x))
   170  	}
   171  
   172  	// no 0-element slices can be read from or written to
   173  	var s int
   174  	shouldPanic(func() {
   175  		s += x[1]
   176  	})
   177  	shouldPanic(func() {
   178  		x[2] = s
   179  	})
   180  }
   181  

View as plain text