when:
        allowFileSystemAccess(false)
        snapshot = read(someFile)
        then:
        assertIsFileSnapshot(snapshot, someFile)

        def missingSubfile = someFile.file("subfile/which/is/deep.txt")
        when:
        snapshot = read(missingSubfile)
        then:
        assertIsMissingFileSnapshot(snapshot, missingSubfile)
    }

    def "can read a missing file"() {

John Howard <******@****.***> 1709232034 -0800

	copied.Annotations["policy.istio.io/checkRetries"] = "0"
	if cfg.Labels["app"] == copied.Labels["app"] ||
		cfg.Annotations["policy.istio.io/checkRetries"] == copied.Annotations["policy.istio.io/checkRetries"] {
		t.Fatalf("Did not deep copy labels and annotations")
	}

	// change the copied gateway to see if the original config is not effected
	copiedGateway := copied.Spec.(*networking.Gateway)
	copiedGateway.Selector = map[string]string{"app": "test"}

}

func (s *podStorage) markSourceSet(source string) {
	s.sourcesSeenLock.Lock()
	defer s.sourcesSeenLock.Unlock()
	s.sourcesSeen.Insert(source)
}

func (s *podStorage) seenSources(sources ...string) bool {
	s.sourcesSeenLock.RLock()
	defer s.sourcesSeenLock.RUnlock()
	return s.sourcesSeen.HasAll(sources...)
}

	call := p.parseCallExpr("defer")
	p.expectSemi()
	if call == nil {
		return &ast.BadStmt{From: pos, To: pos + 5} // len("defer")
	}

	return &ast.DeferStmt{Defer: pos, Call: call}
}

func (p *parser) parseReturnStmt() *ast.ReturnStmt {
	if p.trace {
		defer un(trace(p, "ReturnStmt"))
	}

	pos := p.pos
	p.expect(token.RETURN)
	var x []ast.Expr

		w.(http.Flusher).Flush()
		<-stopCh
	}))
	defer backend.Close()
	defer close(stopCh)

	backendURL, err := url.Parse(backend.URL)
	if err != nil {
		t.Fatal(err)
	}

	proxyHandler := NewSingleHostReverseProxy(backendURL)
	proxyHandler.FlushInterval = time.Microsecond

	frontend := httptest.NewServer(proxyHandler)
	defer frontend.Close()

	//   type fake struct { ... }
	//   func (fake) M () {}
	//
	// These alternative declarations of T use either the std.Real
	// type, introduced in go1.22, or a fake type, for the field
	// F. (The fakery could be arbitrarily deep, involving more
	// nested fields and methods than are shown here.) Clients
	// that use the compatibility shim T will compile with any
	// version of go, whether older or newer than go1.22, but only

	})
	if err != nil {
		return nil, nil, err
	}

	format, err := loadFormatErasure(disk, false)
	if err != nil {
		if errors.Is(err, errUnformattedDisk) {
			info, derr := disk.DiskInfo(context.TODO(), DiskInfoOptions{})
			if derr != nil && info.RootDisk {
				disk.Close()
				return nil, nil, fmt.Errorf("Drive: %s is a root drive", disk)
			}
		}
		disk.Close()

		defer step(t, &steps, 9)
		step(t, &steps, 8)
	}()
	func() {
		defer step(t, &steps, 13)
		defer step(t, &steps, 12)
		func() {
			defer step(t, &steps, 11)
			panic(4)
		}()

		// Code below isn't executed,
		// but removing it breaks the test case.
		defer func() {}()
		defer panic(-1)
		defer step(t, &steps, -1)
		defer step(t, &steps, -1)
		defer func() {}()
	}()

}

func f2() {
	for {
		defer func() { // ERROR "heap-allocated defer"
			fmt.Println("defer1")
		}()
		if glob > 2 {
			break
		}
	}
	defer func() { // ERROR "stack-allocated defer"
		fmt.Println("defer2")
	}()
}

func f3() {
	defer func() { // ERROR "stack-allocated defer"
		fmt.Println("defer2")
	}()
	for {
		defer func() { // ERROR "heap-allocated defer"
			fmt.Println("defer1")
		}()