mode: Terminate
      certificateRefs:
      - name: my-cert-http
        group: core
        kind: unknown
---
apiVersion: gateway.networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: invalid-cert-notfound
  namespace: istio-system
spec:
  addresses:
  - value: istio-ingressgateway
    type: Hostname
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "domain.example"

        }

        @Override
        public DynamicInvokeResult tryGetProperty(String name) {
            Object object = findByName(name);
            return object == null ? DynamicInvokeResult.notFound() : DynamicInvokeResult.found(object);
        }

        @Override
        public Map<String, T> getProperties() {
            return getAsMap();
        }

        @Override

        then:
        result.result == artifactFile
        result.failure == null
        result.hasResult()
    }

    def "can have missing result"() {
        when:
        result.notFound(artifactId)

        then:
        result.failure instanceof ArtifactNotFoundException
        result.hasResult()

        when:
        result.result

        then:

	secondary Verifier
}

var _ Verifier = &fallbackQueryParamVerifier{}

// NewFallbackQueryParamVerifier returns a new Verifier which will invoke the
// initial/primary Verifier. If the primary Verifier is "NotFound", then the
// secondary Verifier is invoked as a fallback.
func NewFallbackQueryParamVerifier(primary Verifier, secondary Verifier) Verifier {
	return &fallbackQueryParamVerifier{
		primary:   primary,

        if (params.length == 1 && params[0] instanceof Closure) {
            return DynamicInvokeResult.found(_container.create(name, (Closure) params[0]));
        }
        return DynamicInvokeResult.notFound();
    }

		if ok {
			gv.Group = requestInfo.APIGroup
			gv.Version = requestInfo.APIVersion
		}
		responsewriters.ErrorNegotiated(err, h.serializer, gv, rw, req)
		return
	}
	http.NotFound(rw, req)

     */
    BuildableComponentResolveResult failed(ModuleVersionResolveException failure);

    /**
     * Marks the component as not found.
     */
    void notFound(ModuleComponentIdentifier versionIdentifier);

    /**
     * Replaces the graph resolution state in the result. Result must already be resolved.
     */
    void setResult(ComponentGraphResolveState state);

        ". Please see "
        "https://www.tensorflow.org/code/"
        "tensorflow/cc/gradients/README.md"
        " for instructions on how to add C++ gradients.";
    return errors::NotFound(error_msg);
  }
  *func = iter->second;
  return absl::OkStatus();
}

}  // end namespace ops

        ModuleDependency markerDependency = getMarkerDependency(pluginRequest);
        String markerVersion = markerDependency.getVersion();
        if (isNullOrEmpty(markerVersion)) {
            return PluginResolutionResult.notFound(SOURCE_NAME, "plugin dependency must include a version number for this source");
        }

        boolean autoApplied = pluginRequest.getOrigin() == PluginRequestInternal.Origin.AUTO_APPLIED;

            return PluginResolutionResult.found(new SimplePluginResolution(DefaultPotentialPluginWithId.of(NOOP_PLUGIN_ID, pluginRegistry.inspect(NoopPlugin.class))));
        }
        return PluginResolutionResult.notFound();
    }

    public static abstract class NoopPlugin implements Plugin<Object> {
        @Override
        public void apply(Object target) {
            // do nothing
        }
    }