}

	_ = w.Close()

	if err := w.Add(name); err == nil {
		t.Error("Expecting error")
	}

	if err := w.Remove(name); err == nil {
		t.Error("Expecting error")
	}

	if ch := w.Errors(name); ch != nil {
		t.Error("Expecting nil")
	}

	if ch := w.Events(name); ch != nil {
		t.Error("Expecting nil")
	}
}

func TestBadWatcher(t *testing.T) {
	w := NewWatcher()

./mc stat minio2/newbucket
if [ $? -ne 0 ]; then
	echo "expecting bucket to be present. exiting.."
	exit_1
fi

./mc stat minio3/newbucket
if [ $? -ne 0 ]; then
	echo "expecting bucket to be present. exiting.."
	exit_1
fi

./mc cp README.md minio2/newbucket/

sleep 5
./mc stat minio1/newbucket/README.md
if [ $? -ne 0 ]; then
	echo "expecting object to be present. exiting.."
	exit_1
fi

if [ $? -ne 0 ]; then
	echo "expecting the command to succeed, exiting.."
	exit_1
fi
./mc admin policy info minio3 projecta >/dev/null 2>&1
if [ $? -ne 0 ]; then
	echo "expecting the command to succeed, exiting.."
	exit_1
fi

./mc admin policy remove minio3 projecta

sleep 10
./mc admin policy info minio1 projecta
if [ $? -eq 0 ]; then
	echo "expecting the command to fail, exiting.."
	exit_1
fi

		s, _ := status.FromError(err)
		code := s.Code()
		if code != c.code {
			t.Errorf("Case %s: expecting code to be (%d) but got (%d): %s", id, c.code, code, s.Message())
		} else if c.code == codes.OK {
			if len(response.CertChain) != len(mockCertChain) {
				t.Errorf("Case %s: expecting cert chain length to be (%d) but got (%d)",
					id, len(mockCertChain), len(response.CertChain))
			}

				},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.Name, func(t *testing.T) {
			actual := HeaderMatcher(tc.K, tc.V)
			if !cmp.Equal(tc.Expect, actual, protocmp.Transform()) {
				t.Errorf("expecting %v, but got %v", tc.Expect, actual)
			}
		})
	}
}

func TestHostMatcherWithRegex(t *testing.T) {
	testCases := []struct {
		Name   string
		K      string
		V      string

// Verify that erroneous switch statements are detected by the compiler.
// Does not compile.

package main

func f() {
	switch {
	case 0; // ERROR "expecting := or = or : or comma|expected :"
	}

	switch {
	case 0; // ERROR "expecting := or = or : or comma|expected :"
	default:
	}

	switch {
	case 0: case 0: default:
	}

	switch {
	case 0: f(); case 0:

			} else if !isSpace(ch) {
				return errors.New("invalid header configuration. Expecting ',', ']', or whitespace")
			}

		case ExpectStringParserState:
			// Skip over whitespace looking for the starting quote of a JSON string.
			if ch == '"' {
				state = StringParserState
			} else if !isSpace(ch) {
				return errors.New("invalid header configuration. Expecting '\"'")
			}

		case StringParserState:

				v, ok := c.Get(key)
				if !ok {
					t.Errorf("Got false for key %s, expecting true", key)
				} else if v.(int) != j {
					t.Errorf("Got %d for key %s, expecting %d", v, key, j)
				}
				c.Remove(key)
			}
			wg.Done()
		}()
	}
	wg.Wait()

	stats := c.Stats()
	if stats.Misses != 0 {
		t.Errorf("Got %d misses, expecting %d", stats.Misses, 0)
	}

	if stats.Hits != uint64(workers*numIters) {

                unitSuccess
            } else if (tokenType == IDENTIFIER) {
                failure("Expecting symbol '$s', but got '$tokenText' instead")
            } else if (tokenType == null) {
                failure("Expecting symbol '$s'")
            } else {
                failure("Expecting symbol '$s', but got a token of type '$tokenType' instead")
            }
        }
    }


    internal

     *
     * @return null when this handler is not expecting any further requests.
     */
    @Nullable
    ResponseProducer selectResponseProducer(int id, HttpExchange exchange);

    boolean expecting(HttpExchange exchange);

    /**
     * Returns a precondition that asserts that this handler is not expecting any further requests to be released by the test in order to complete.
     */