urlIterator.remove()
      }
    }
```

### Troubleshooting

1. Valid cacheable responses are not being cached

Make sure you are reading responses fully as unless they are read fully, cancelled or stalled Responses will not be cached.

### Overriding normal cache behaviour

//
// If earlyCloseFn is non-nil and Close is called before io.EOF is
// seen, earlyCloseFn is called instead of fn, and its return value is
// the return value from Close.
type bodyEOFSignal struct {
	body         io.ReadCloser
	mu           sync.Mutex        // guards following 4 fields
	closed       bool              // whether Close has been called
	rerr         error             // sticky Read error

            }
            container.addLater(provider { create(Base) })
        """
        expect:
        succeeds("help")
        outputContains("withType(Base) called on ")
    }
    def "addLater(Base) triggers configuration with eager withType(Sub)"() {
        buildFile << """
            container.withType(Sub) {
                println "withType(Sub) called on " + it
            }

func TestCachedHasSynced(t *testing.T) {

	called := 0
	result := false
	cachedFunc := cachedHasSynced(func() bool {
		called++
		return result
	})

	if cachedFunc() {
		t.Fatal("expected false")
	}
	if called != 1 {
		t.Fatalf("expected called=1, got %d", called)
	}

	if cachedFunc() {
		t.Fatal("expected false")
	}
	if called != 2 {
		t.Fatalf("expected called=2, got %d", called)
	}

	result = true

    def "one arg closure called with subject and no inputs"() {
        given:
        def called = false
        String thing = "1"
        def closure = { String val ->
            called = true
            assert val.is(thing)
            assert delegate.is(thing)
        }

        when:
        action(closure).execute(thing, [])

        then:
        called
    }

        given:
        def called = false
        def action = filter(action { called = true }, spec { true })

        when:
        action.execute "object"

        then:
        called
    }

    def "filtered action doesnt fire for not matching"() {
        given:
        def called = false
        def action = filter(action { called = true }, spec { false })

        when:

	// GotFirstResponseByte is called when the first byte of the response
	// headers is available.
	GotFirstResponseByte func()

	// Got100Continue is called if the server replies with a "100
	// Continue" response.
	Got100Continue func()

	// Got1xxResponse is called for each 1xx informational response header
	// returned before the final non-1xx response. Got1xxResponse is called

import (
	"fmt"
	"os"
	"testing"
)

var called = false

func TestMain(m *testing.M) {
	m.Run()
	if !called {
		fmt.Println("benchmark never called")
		os.Exit(1)
	}
}

func Benchmark(b *testing.B) {
	if b.N > 1 {
		b.Fatalf("called with b.N=%d; want b.N=1 only", b.N)
	}
	if called {
		b.Fatal("called twice")
	}
	called = true

	}
	if called != 1 {
		t.Fatalf("First call should call the getter, has called = %v", called)
	}

	_, err = finder.HasCRD(schema.GroupKind{Group: "", Kind: "Pod"})
	if err != nil {
		t.Fatalf("Failed to call HasCRD: %v", err)
	}
	if called != 1 {
		t.Fatalf("Second call should NOT call the getter, has called = %v", called)
	}
}

func TestCRDFinderErrors(t *testing.T) {

                calledFirst.set(true);
                assertFalse(called.get());
                QueryBuilder builder = chain.execute(context, query, boost);
                assertTrue(called.get());
                return builder;
            }
        });
        queryBuilder = queryProcessor.execute(context, query, 1.0f);
        assertTrue(called.get());
        assertTrue(calledFirst.get());