...
Run Format

Source file src/os/env_test.go

Documentation: os

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package os_test
     6  
     7  import (
     8  	. "os"
     9  	"reflect"
    10  	"strings"
    11  	"testing"
    12  )
    13  
    14  // testGetenv gives us a controlled set of variables for testing Expand.
    15  func testGetenv(s string) string {
    16  	switch s {
    17  	case "*":
    18  		return "all the args"
    19  	case "#":
    20  		return "NARGS"
    21  	case "$":
    22  		return "PID"
    23  	case "1":
    24  		return "ARGUMENT1"
    25  	case "HOME":
    26  		return "/usr/gopher"
    27  	case "H":
    28  		return "(Value of H)"
    29  	case "home_1":
    30  		return "/usr/foo"
    31  	case "_":
    32  		return "underscore"
    33  	}
    34  	return ""
    35  }
    36  
    37  var expandTests = []struct {
    38  	in, out string
    39  }{
    40  	{"", ""},
    41  	{"$*", "all the args"},
    42  	{"$$", "PID"},
    43  	{"${*}", "all the args"},
    44  	{"$1", "ARGUMENT1"},
    45  	{"${1}", "ARGUMENT1"},
    46  	{"now is the time", "now is the time"},
    47  	{"$HOME", "/usr/gopher"},
    48  	{"$home_1", "/usr/foo"},
    49  	{"${HOME}", "/usr/gopher"},
    50  	{"${H}OME", "(Value of H)OME"},
    51  	{"A$$$#$1$H$home_1*B", "APIDNARGSARGUMENT1(Value of H)/usr/foo*B"},
    52  	{"start$+middle$^end$", "start$+middle$^end$"},
    53  	{"mixed$|bag$$$", "mixed$|bagPID$"},
    54  	{"$", "$"},
    55  	{"$}", "$}"},
    56  	{"${", ""},  // invalid syntax; eat up the characters
    57  	{"${}", ""}, // invalid syntax; eat up the characters
    58  }
    59  
    60  func TestExpand(t *testing.T) {
    61  	for _, test := range expandTests {
    62  		result := Expand(test.in, testGetenv)
    63  		if result != test.out {
    64  			t.Errorf("Expand(%q)=%q; expected %q", test.in, result, test.out)
    65  		}
    66  	}
    67  }
    68  
    69  var global interface{}
    70  
    71  func BenchmarkExpand(b *testing.B) {
    72  	b.Run("noop", func(b *testing.B) {
    73  		var s string
    74  		b.ReportAllocs()
    75  		for i := 0; i < b.N; i++ {
    76  			s = Expand("tick tick tick tick", func(string) string { return "" })
    77  		}
    78  		global = s
    79  	})
    80  	b.Run("multiple", func(b *testing.B) {
    81  		var s string
    82  		b.ReportAllocs()
    83  		for i := 0; i < b.N; i++ {
    84  			s = Expand("$a $a $a $a", func(string) string { return "boom" })
    85  		}
    86  		global = s
    87  	})
    88  }
    89  
    90  func TestConsistentEnviron(t *testing.T) {
    91  	e0 := Environ()
    92  	for i := 0; i < 10; i++ {
    93  		e1 := Environ()
    94  		if !reflect.DeepEqual(e0, e1) {
    95  			t.Fatalf("environment changed")
    96  		}
    97  	}
    98  }
    99  
   100  func TestUnsetenv(t *testing.T) {
   101  	const testKey = "GO_TEST_UNSETENV"
   102  	set := func() bool {
   103  		prefix := testKey + "="
   104  		for _, key := range Environ() {
   105  			if strings.HasPrefix(key, prefix) {
   106  				return true
   107  			}
   108  		}
   109  		return false
   110  	}
   111  	if err := Setenv(testKey, "1"); err != nil {
   112  		t.Fatalf("Setenv: %v", err)
   113  	}
   114  	if !set() {
   115  		t.Error("Setenv didn't set TestUnsetenv")
   116  	}
   117  	if err := Unsetenv(testKey); err != nil {
   118  		t.Fatalf("Unsetenv: %v", err)
   119  	}
   120  	if set() {
   121  		t.Fatal("Unsetenv didn't clear TestUnsetenv")
   122  	}
   123  }
   124  
   125  func TestClearenv(t *testing.T) {
   126  	const testKey = "GO_TEST_CLEARENV"
   127  	const testValue = "1"
   128  
   129  	// reset env
   130  	defer func(origEnv []string) {
   131  		for _, pair := range origEnv {
   132  			// Environment variables on Windows can begin with =
   133  			// https://blogs.msdn.com/b/oldnewthing/archive/2010/05/06/10008132.aspx
   134  			i := strings.Index(pair[1:], "=") + 1
   135  			if err := Setenv(pair[:i], pair[i+1:]); err != nil {
   136  				t.Errorf("Setenv(%q, %q) failed during reset: %v", pair[:i], pair[i+1:], err)
   137  			}
   138  		}
   139  	}(Environ())
   140  
   141  	if err := Setenv(testKey, testValue); err != nil {
   142  		t.Fatalf("Setenv(%q, %q) failed: %v", testKey, testValue, err)
   143  	}
   144  	if _, ok := LookupEnv(testKey); !ok {
   145  		t.Errorf("Setenv(%q, %q) didn't set $%s", testKey, testValue, testKey)
   146  	}
   147  	Clearenv()
   148  	if val, ok := LookupEnv(testKey); ok {
   149  		t.Errorf("Clearenv() didn't clear $%s, remained with value %q", testKey, val)
   150  	}
   151  }
   152  
   153  func TestLookupEnv(t *testing.T) {
   154  	const smallpox = "SMALLPOX"      // No one has smallpox.
   155  	value, ok := LookupEnv(smallpox) // Should not exist.
   156  	if ok || value != "" {
   157  		t.Fatalf("%s=%q", smallpox, value)
   158  	}
   159  	defer Unsetenv(smallpox)
   160  	err := Setenv(smallpox, "virus")
   161  	if err != nil {
   162  		t.Fatalf("failed to release smallpox virus")
   163  	}
   164  	_, ok = LookupEnv(smallpox)
   165  	if !ok {
   166  		t.Errorf("smallpox release failed; world remains safe but LookupEnv is broken")
   167  	}
   168  }
   169  

View as plain text