text: // Copyright 2011 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.
  
  // This file contains examples to embed in the Go 1 release notes document.
  
  package main
  
  import (
  	"errors"
  	"flag"
  	"fmt"
  	"log"
  	"os"
  	"path/filepath"
  	"testing"
  	"time"
  	"unicode"
  )
  
  func main() {
  	flag.Parse()
  	stringAppend()
  	mapDelete()
  	mapIteration()
  	multipleAssignment()
  	structEquality()
  	compositeLiterals()
  	runeType()
  	errorExample()
  	timePackage()
  	walkExample()
  	osIsExist()
  }
  
  var timeout = flag.Duration("timeout", 30*time.Second, "how long to wait for completion")
  
  func init() {
  	// canonicalize the logging
  	log.SetFlags(0)
  }
  
  func mapDelete() {
  	m := map[string]int{"7": 7, "23": 23}
  	k := "7"
  	delete(m, k)
  	if m["7"] != 0 || m["23"] != 23 {
  		log.Fatal("mapDelete:", m)
  	}
  }
  
  func stringAppend() {
  	greeting := []byte{}
  	greeting = append(greeting, []byte("hello ")...)
  	greeting = append(greeting, "world"...)
  	if string(greeting) != "hello world" {
  		log.Fatal("stringAppend: ", string(greeting))
  	}
  }
  
  func mapIteration() {
  	m := map[string]int{"Sunday": 0, "Monday": 1}
  	for name, value := range m {
  		// This loop should not assume Sunday will be visited first.
  		f(name, value)
  	}
  }
  
  func f(string, int) {
  }
  
  func assert(t bool) {
  	if !t {
  		log.Panic("assertion fail")
  	}
  }
  
  func multipleAssignment() {
  	sa := []int{1, 2, 3}
  	i := 0
  	i, sa[i] = 1, 2 // sets i = 1, sa[0] = 2
  
  	sb := []int{1, 2, 3}
  	j := 0
  	sb[j], j = 2, 1 // sets sb[0] = 2, j = 1
  
  	sc := []int{1, 2, 3}
  	sc[0], sc[0] = 1, 2 // sets sc[0] = 1, then sc[0] = 2 (so sc[0] = 2 at end)
  
  	assert(i == 1 && sa[0] == 2)
  	assert(j == 1 && sb[0] == 2)
  	assert(sc[0] == 2)
  }
  
  func structEquality() {
  	type Day struct {
  		long  string
  		short string
  	}
  	Christmas := Day{"Christmas", "XMas"}
  	Thanksgiving := Day{"Thanksgiving", "Turkey"}
  	holiday := map[Day]bool{
  		Christmas:    true,
  		Thanksgiving: true,
  	}
  	fmt.Printf("Christmas is a holiday: %t\n", holiday[Christmas])
  }
  
  func compositeLiterals() {
  	type Date struct {
  		month string
  		day   int
  	}
  	// Struct values, fully qualified; always legal.
  	holiday1 := []Date{
  		Date{"Feb", 14},
  		Date{"Nov", 11},
  		Date{"Dec", 25},
  	}
  	// Struct values, type name elided; always legal.
  	holiday2 := []Date{
  		{"Feb", 14},
  		{"Nov", 11},
  		{"Dec", 25},
  	}
  	// Pointers, fully qualified, always legal.
  	holiday3 := []*Date{
  		&Date{"Feb", 14},
  		&Date{"Nov", 11},
  		&Date{"Dec", 25},
  	}
  	// Pointers, type name elided; legal in Go 1.
  	holiday4 := []*Date{
  		{"Feb", 14},
  		{"Nov", 11},
  		{"Dec", 25},
  	}
  	// STOP OMIT
  	_, _, _, _ = holiday1, holiday2, holiday3, holiday4
  }
  
  func runeType() {
  	// STARTRUNE OMIT
  	delta := 'δ' // delta has type rune.
  	var DELTA rune
  	DELTA = unicode.ToUpper(delta)
  	epsilon := unicode.ToLower(DELTA + 1)
  	if epsilon != 'δ'+1 {
  		log.Fatal("inconsistent casing for Greek")
  	}
  	// ENDRUNE OMIT
  }
  
  // START ERROR EXAMPLE OMIT
  type SyntaxError struct {
  	File    string
  	Line    int
  	Message string
  }
  
  func (se *SyntaxError) Error() string {
  	return fmt.Sprintf("%s:%d: %s", se.File, se.Line, se.Message)
  }
  
  // END ERROR EXAMPLE OMIT
  
  func errorExample() {
  	var ErrSyntax = errors.New("syntax error")
  	_ = ErrSyntax
  	se := &SyntaxError{"file", 7, "error"}
  	got := fmt.Sprint(se)
  	const expect = "file:7: error"
  	if got != expect {
  		log.Fatalf("errorsPackage: expected %q got %q", expect, got)
  	}
  }
  
  // sleepUntil sleeps until the specified time. It returns immediately if it's too late.
  func sleepUntil(wakeup time.Time) {
  	now := time.Now() // A Time.
  	if !wakeup.After(now) {
  		return
  	}
  	delta := wakeup.Sub(now) // A Duration.
  	fmt.Printf("Sleeping for %.3fs\n", delta.Seconds())
  	time.Sleep(delta)
  }
  
  func timePackage() {
  	sleepUntil(time.Now().Add(123 * time.Millisecond))
  }
  
  func walkExample() {
  	// STARTWALK OMIT
  	markFn := func(path string, info os.FileInfo, err error) error {
  		if path == "pictures" { // Will skip walking of directory pictures and its contents.
  			return filepath.SkipDir
  		}
  		if err != nil {
  			return err
  		}
  		log.Println(path)
  		return nil
  	}
  	err := filepath.Walk(".", markFn)
  	if err != nil {
  		log.Fatal(err)
  	}
  	// ENDWALK OMIT
  }
  
  func initializationFunction(c chan int) {
  	c <- 1
  }
  
  var PackageGlobal int
  
  func init() {
  	c := make(chan int)
  	go initializationFunction(c)
  	PackageGlobal = <-c
  }
  
  func BenchmarkSprintf(b *testing.B) {
  	// Verify correctness before running benchmark.
  	b.StopTimer()
  	got := fmt.Sprintf("%x", 23)
  	const expect = "17"
  	if expect != got {
  		b.Fatalf("expected %q; got %q", expect, got)
  	}
  	b.StartTimer()
  	for i := 0; i < b.N; i++ {
  		fmt.Sprintf("%x", 23)
  	}
  }
  
  func osIsExist() {
  	name := "go1.go"
  	f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
  	if os.IsExist(err) {
  		log.Printf("%s already exists", name)
  	}
  	_ = f
  }
  