if (name == "dyno") {
                    return DynamicInvokeResult.found(Arrays.toString(arguments))
                }
                return DynamicInvokeResult.notFound()
            }
        }
    }

    Object methodMissing(String name, Object params) {
        throw new AssertionError("Should not be called")
    }

            if (arguments.length == 0) {
                return DynamicInvokeResult.notFound();
            }
            Configuration configuration = configurationContainer.findByName(name);
            if (configuration == null) {
                return DynamicInvokeResult.notFound();
            }
            List<Object> normalizedArgs = GUtil.flatten(Arrays.asList(arguments), false);

      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 (result == null) {
                return notFound(serviceType);
            }
            return result;
        }

        @Override
        public Object get(Type serviceType, Class<? extends Annotation> annotatedWith) throws UnknownServiceException, ServiceLookupException {
            return notFound(serviceType);
        }

        private Object notFound(Type serviceType) {

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

.btn.btn-istio:active {
    background-color: #e07484
}

.notfound {
    text-align: center
}

.notfound .icon {
    margin-top: 9rem
}

.notfound .icon img {
    height: 12rem
}

.notfound .error {
    padding: 2rem 0 0 0;
    font-weight: 700;
    font-size: 200%
}

.notfound .explanation {
    padding: 2rem 0 9rem 0;
    font-weight: 300;

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