func NewError(s string) error { return ErrorString(s) }

func (e ErrorString) Is(target error) bool {
	switch target {
	case oserror.ErrPermission:
		return checkErrMessageContent(e, "permission denied")
	case oserror.ErrExist:
		return checkErrMessageContent(e, "exists", "is a directory")
	case oserror.ErrNotExist:
		return checkErrMessageContent(e, "does not exist", "not found",
			"has been removed", "no parent")

        this.resolutionHost = resolutionHost;
        this.visitedArtifacts = visitedArtifacts;
        this.configuration = configuration;
    }

    @Override
    public boolean hasError() {
        return graphResults.hasAnyFailure();
    }

    @Override
    public void rethrowFailure() throws ResolveException {
        if (!graphResults.hasAnyFailure()) {
            return;
        }

	// Unavailable or canceled code will be sent when a connection is closing down. This is very normal,
	// due to the XDS connection being dropped every 30 minutes, or a pod shutting down.
	isError := s.Code() != codes.Unavailable && s.Code() != codes.Canceled
	return !ok || isError
}

// recordSendError records a metric indicating that a push failed. It returns true if this was an unexpected
// error

        if (response.hasError()) {
            logger.warn("Failed to delete all words.", response.getErrors().get(0));
            return false;
        }
        refresh();
        return true;
    }

    public boolean deleteDocumentWords() {
        final SuggestDeleteResponse response = suggester.indexer().deleteDocumentWords();
        if (response.hasError()) {

task someTask(type: SomeTask) {
    v = $initialValue
    d = file("build/out")
}
"""
        def isError = expectedValidationProblem != null

        when:
        if (isError) {
            fails 'someTask'
        } else {
            succeeds "someTask"
        }

        then:
        if (isError) {
            failure.error.contains(expectedValidationProblem)
        }

        when:

			return s
		}
	}
	return "errno " + itoa.Itoa(int(e))
}

func (e Errno) Is(target error) bool {
	switch target {
	case oserror.ErrPermission:
		return e == EACCES || e == EPERM
	case oserror.ErrExist:
		return e == EEXIST || e == ENOTEMPTY
	case oserror.ErrNotExist:
		return e == ENOENT
	case errorspkg.ErrUnsupported:
		return e == ENOSYS || e == ENOTSUP || e == EOPNOTSUPP
	}
	return false
}

    }

    data object ErrorResolution : DocumentNodeResolution, UnsuccessfulResolution {
        override val reasons: Iterable<ResolutionFailureReason>
            get() = listOf(IsError)
    }

    sealed interface ValueNodeResolution : DocumentResolution {
        data class LiteralValueResolved(val value: Any) : ValueNodeResolution, SuccessfulResolution

	c := t.Clusters().Default()

	x, err := c.Istio().NetworkingV1alpha3().VirtualServices(ns.Name()).Get(context.TODO(), "reviews", metav1.GetOptions{})
	if err != nil {
		t.Fatalf("unexpected test failure: can't get virtualservice: %v", err)
	}

	status := &x.Status

	if hasError {
		if len(status.ValidationMessages) < 1 {

        protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
            mark(in);
            mark(out);

            CoderResult coderResult = decoder.decode(in, out, false);

            if (coderResult.isError() && utf8) {
                reset(in);
                reset(out);
                // Fallback to the ISO_8859_1 decoder
                decoder = StandardCharsets.ISO_8859_1.newDecoder();
                utf8 = false;

	{"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
		[]string{"foo", "bar"},
		[]string{" FOO ", " BAR "}},
	// errors
	{"missing end", `{{define "foo"}} FOO `, hasError,
		nil,
		nil},
	{"malformed name", `{{define "foo}} FOO `, hasError,
		nil,
		nil},
}

func TestMultiParse(t *testing.T) {
	for _, test := range multiParseTests {
		template, err := New("root").Parse(test.input)
		switch {