original := file.AsStringOrFail(t, "/etc/nsswitch.conf")
	var sandboxed string

	originalNetNS, err := netns.Get()
	assert.NoError(t, err)
	var sandboxedNetNS netns.NsHandle

	// Due to unshare-go imports above, this can run
	assert.NoError(t, runInSandbox("", func() error {
		// We should have overwritten this file with /dev/null
		sandboxed = file.AsStringOrFail(t, "/etc/nsswitch.conf")
		sandboxedNetNS, err = netns.Get()

    key: "shape"
    value {
      shape {
      }
    }
  }
}
node {
  name: "cond/Switch"
  op: "Switch"
  input: "Placeholder_1"
  input: "Placeholder_1"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "cond/switch_t"
  op: "Identity"
  input: "cond/Switch:1"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {

		use(x)
	}
}

// Formatting of switch-statement headers.
func _() {
	switch {
	}
	switch {
	}	// no semicolon printed
	switch expr {
	}
	switch expr {
	}	// no semicolon printed
	switch expr {
	}	// no parens printed
	switch expr {
	}	// no semicolon and parens printed
	switch x := expr; {
	default:
		use(
			x)
	}
	switch x := expr; expr {
	default:
		use(x)
	}

// Verify that type switch statements with duplicate cases are detected
// by the compiler.
// Does not compile.

package main

import "fmt"

func f4(e interface{}) {
	switch e.(type) {
	case int:
	case int: // ERROR "duplicate case int in type switch"
	case int64:
	case error:
	case error: // ERROR "duplicate case error in type switch"
	case fmt.Stringer:

	case 5.0: // ERROR "duplicate case (5 in switch)?"
	}
}

func f2(s string) {
	switch s {
	case "":
	case "": // ERROR "duplicate case (.. in switch)?"
	case "abc":
	case "abc": // ERROR "duplicate case (.abc. in switch)?"
	}
}

func f3(e interface{}) {
	switch e {
	case 0:
	case 0: // ERROR "duplicate case (0 in switch)?"
	case int64(0):
	case float32(10):

type switch header or in the case.

See also issue 4470.
*/
package p

func f() {
	var x interface{}
	switch x.(type) { // should remain the same
	}
	switch (x.(type)) { // should become: switch x.(type) {
	}

	switch x.(type) { // should remain the same
	case int:
	}
	switch (x.(type)) { // should become: switch x.(type) {
	case int:
	}

	switch x.(type) { // should remain the same
	case []int:

type P *struct{}

func _() {
	// want an error even if the switch is empty
	var a struct{ _ func() }
	switch a /* ERROR "cannot switch on a" */ {
	}

	switch a /* ERROR "cannot switch on a" */ {
	case a: // no follow-on error here
	}

	// this is ok because f can be compared to nil
	var f func()
	switch f {
	}

	switch f {
	case nil:
	}

	switch (func())(nil) {
	case nil:
	}

type switch header or in the case.

See also issue 4470.
*/
package p

func f() {
	var x interface{}
	switch x.(type) { // should remain the same
	}
	switch x.(type) { // should become: switch x.(type) {
	}

	switch x.(type) { // should remain the same
	case int:
	}
	switch x.(type) { // should become: switch x.(type) {
	case int:
	}

	switch x.(type) { // should remain the same
	case []int:
	}

	default:
	}

	var ar, ar1 [4]func()
	switch ar { // ERROR "cannot switch on"
	case ar1:
	default:
	}

	var st, st1 struct{ f func() }
	switch st { // ERROR "cannot switch on"
	case st1:
	}
}

func good() {
	var i interface{}
	var s string

	switch i {
	case s:
	}

	switch s {
	case i:
	}

// license that can be found in the LICENSE file.

package main

func f[T comparable](i any) {
	var t T

	switch i {
	case t:
		// ok
	default:
		println("FAIL: switch i")
	}

	switch t {
	case i:
		// ok
	default:
		println("FAIL: switch t")
	}
}

type myint int

func (m myint) foo() {
}

type fooer interface {
	foo()
}