assertTrue(iterable.allMatch(predicate));
    list.add("pants");
    assertFalse(iterable.allMatch(predicate));
  }

  public void testFirstMatch() {
    FluentIterable<String> iterable = FluentIterable.from(Lists.newArrayList("cool", "pants"));
    assertThat(iterable.firstMatch(equalTo("cool"))).hasValue("cool");
    assertThat(iterable.firstMatch(equalTo("pants"))).hasValue("pants");

                    "required": ["username", "password"],
                    "type": "object",
                    "properties": {
                        "grant_type": {
                            "title": "Grant Type",
                            "anyOf": [
                                {"pattern": "^password$", "type": "string"},
                                {"type": "null"},
                            ],

// just enough to support pprof.
//
// Usage:
//
//	go tool addr2line binary
//
// Addr2line reads hexadecimal addresses, one per line and with optional 0x prefix,
// from standard input. For each input address, addr2line prints two output lines,
// first the name of the function containing the address and second the file:line
// of the source code corresponding to that address.
//

                    "required": ["grant_type", "username", "password"],
                    "type": "object",
                    "properties": {
                        "grant_type": {
                            "title": "Grant Type",
                            "pattern": "^password$",
                            "type": "string",
                        },
                        "username": {"title": "Username", "type": "string"},

                    "required": ["grant_type", "username", "password"],
                    "type": "object",
                    "properties": {
                        "grant_type": {
                            "title": "Grant Type",
                            "pattern": "^password$",
                            "type": "string",
                        },
                        "username": {"title": "Username", "type": "string"},

func Unwrap(c net.Conn) net.Conn {
	if dc, ok := c.(*DeadlineConn); ok {
		return dc.Conn
	}
	return c
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	// Do not set a Read deadline, if upstream wants to cancel all reads.
	if c.readDeadline <= 0 || c.abortReads.Load() || c.infReads.Load() {
		return
	}

	c.mu.Lock()
	defer c.mu.Unlock()
	if c.abortReads.Load() {
		return
	}

	now := time.Now()

  echo 'already sourced a TFCI env file with "set -a; source <path>; set +a".'
  echo 'If you have not, you will see a lot of undefined variable errors.'
else
  FROM_ENV=$(mktemp)
  # "export -p" prints a list of environment values in a safe-to-source format,
  # e.g. `declare -x TFCI_BAZEL_COMMON_ARGS="list of args"` for bash.
  export -p | grep TFCI > "$FROM_ENV"

  # Source the default ci values

                    "required": ["grant_type", "username", "password"],
                    "type": "object",
                    "properties": {
                        "grant_type": {
                            "title": "Grant Type",
                            "pattern": "^password$",
                            "type": "string",
                        },
                        "username": {"title": "Username", "type": "string"},

	const isWriteLock = true
	return lm.lockLoop(ctx, id, source, timeout, isWriteLock)
}

// RLock holds a read lock on lm.
//
// If one or more read lock are already in use, it will grant another lock.
// Otherwise the calling go routine blocks until the mutex is available.
func (lm *LRWMutex) RLock() {
	const isWriteLock = false
	lm.lockLoop(context.Background(), lm.id, lm.source, 1<<63-1, isWriteLock)
}

	flag.StringVar(&bucket, "bucket", "", "Select a specific bucket")
	flag.StringVar(&prefix, "prefix", "", "Select a prefix")
	flag.BoolVar(&debug, "debug", false, "Prints HTTP network calls to S3 endpoint")
	flag.BoolVar(&versions, "versions", false, "Verify all versions")
	flag.BoolVar(&insecure, "insecure", false, "Disable TLS verification")