complit.go

Documentation: golang.org/x/tools/go/ssa/interp/testdata

     1  package main
     2  
     3  // Tests of composite literals.
     4  
     5  import "fmt"
     6  
     7  // Map literals.
     8  // TODO(adonovan): we can no longer print maps
     9  // until the interpreter supports (reflect.Value).MapRange.
    10  func _() {
    11  	type M map[int]int
    12  	m1 := []*M{{1: 1}, &M{2: 2}}
    13  	want := "map[1:1] map[2:2]"
    14  	if got := fmt.Sprint(*m1[0], *m1[1]); got != want {
    15  		panic(got)
    16  	}
    17  	m2 := []M{{1: 1}, M{2: 2}}
    18  	if got := fmt.Sprint(m2[0], m2[1]); got != want {
    19  		panic(got)
    20  	}
    21  }
    22  
    23  // Nonliteral keys in composite literal.
    24  func init() {
    25  	const zero int = 1
    26  	var v = []int{1 + zero: 42}
    27  	if x := fmt.Sprint(v); x != "[0 0 42]" {
    28  		panic(x)
    29  	}
    30  }
    31  
    32  // Test for in-place initialization.
    33  func init() {
    34  	// struct
    35  	type S struct {
    36  		a, b int
    37  	}
    38  	s := S{1, 2}
    39  	s = S{b: 3}
    40  	if s.a != 0 {
    41  		panic("s.a != 0")
    42  	}
    43  	if s.b != 3 {
    44  		panic("s.b != 3")
    45  	}
    46  	s = S{}
    47  	if s.a != 0 {
    48  		panic("s.a != 0")
    49  	}
    50  	if s.b != 0 {
    51  		panic("s.b != 0")
    52  	}
    53  
    54  	// array
    55  	type A [4]int
    56  	a := A{2, 4, 6, 8}
    57  	a = A{1: 6, 2: 4}
    58  	if a[0] != 0 {
    59  		panic("a[0] != 0")
    60  	}
    61  	if a[1] != 6 {
    62  		panic("a[1] != 6")
    63  	}
    64  	if a[2] != 4 {
    65  		panic("a[2] != 4")
    66  	}
    67  	if a[3] != 0 {
    68  		panic("a[3] != 0")
    69  	}
    70  	a = A{}
    71  	if a[0] != 0 {
    72  		panic("a[0] != 0")
    73  	}
    74  	if a[1] != 0 {
    75  		panic("a[1] != 0")
    76  	}
    77  	if a[2] != 0 {
    78  		panic("a[2] != 0")
    79  	}
    80  	if a[3] != 0 {
    81  		panic("a[3] != 0")
    82  	}
    83  }
    84  
    85  // Regression test for https://golang.org/issue/10127:
    86  // composite literal clobbers destination before reading from it.
    87  func init() {
    88  	// map
    89  	{
    90  		type M map[string]int
    91  		m := M{"x": 1, "y": 2}
    92  		m = M{"x": m["y"], "y": m["x"]}
    93  		if m["x"] != 2 || m["y"] != 1 {
    94  			panic(fmt.Sprint(m))
    95  		}
    96  
    97  		n := M{"x": 3}
    98  		m, n = M{"x": n["x"]}, M{"x": m["x"]} // parallel assignment
    99  		if got := fmt.Sprint(m["x"], n["x"]); got != "3 2" {
   100  			panic(got)
   101  		}
   102  	}
   103  
   104  	// struct
   105  	{
   106  		type T struct{ x, y, z int }
   107  		t := T{x: 1, y: 2, z: 3}
   108  
   109  		t = T{x: t.y, y: t.z, z: t.x} // all fields
   110  		if got := fmt.Sprint(t); got != "{2 3 1}" {
   111  			panic(got)
   112  		}
   113  
   114  		t = T{x: t.y, y: t.z + 3} // not all fields
   115  		if got := fmt.Sprint(t); got != "{3 4 0}" {
   116  			panic(got)
   117  		}
   118  
   119  		u := T{x: 5, y: 6, z: 7}
   120  		t, u = T{x: u.x}, T{x: t.x} // parallel assignment
   121  		if got := fmt.Sprint(t, u); got != "{5 0 0} {3 0 0}" {
   122  			panic(got)
   123  		}
   124  	}
   125  
   126  	// array
   127  	{
   128  		a := [3]int{0: 1, 1: 2, 2: 3}
   129  
   130  		a = [3]int{0: a[1], 1: a[2], 2: a[0]} //  all elements
   131  		if got := fmt.Sprint(a); got != "[2 3 1]" {
   132  			panic(got)
   133  		}
   134  
   135  		a = [3]int{0: a[1], 1: a[2] + 3} //  not all elements
   136  		if got := fmt.Sprint(a); got != "[3 4 0]" {
   137  			panic(got)
   138  		}
   139  
   140  		b := [3]int{0: 5, 1: 6, 2: 7}
   141  		a, b = [3]int{0: b[0]}, [3]int{0: a[0]} // parallel assignment
   142  		if got := fmt.Sprint(a, b); got != "[5 0 0] [3 0 0]" {
   143  			panic(got)
   144  		}
   145  	}
   146  
   147  	// slice
   148  	{
   149  		s := []int{0: 1, 1: 2, 2: 3}
   150  
   151  		s = []int{0: s[1], 1: s[2], 2: s[0]} //  all elements
   152  		if got := fmt.Sprint(s); got != "[2 3 1]" {
   153  			panic(got)
   154  		}
   155  
   156  		s = []int{0: s[1], 1: s[2] + 3} //  not all elements
   157  		if got := fmt.Sprint(s); got != "[3 4]" {
   158  			panic(got)
   159  		}
   160  
   161  		t := []int{0: 5, 1: 6, 2: 7}
   162  		s, t = []int{0: t[0]}, []int{0: s[0]} // parallel assignment
   163  		if got := fmt.Sprint(s, t); got != "[5] [3]" {
   164  			panic(got)
   165  		}
   166  	}
   167  }
   168  
   169  // Regression test for https://golang.org/issue/13341:
   170  // within a map literal, if a key expression is a composite literal,
   171  // Go 1.5 allows its type to be omitted.  An & operation may be implied.
   172  func init() {
   173  	type S struct{ x int }
   174  	// same as map[*S]bool{&S{x: 1}: true}
   175  	m := map[*S]bool{{x: 1}: true}
   176  	for s := range m {
   177  		if s.x != 1 {
   178  			panic(s) // wrong key
   179  		}
   180  		return
   181  	}
   182  	panic("map is empty")
   183  }
   184  
   185  func main() {
   186  }
   187
View as plain text