details.componentId >> DefaultModuleComponentIdentifier.newId(fooMod, version)
        action.execute(details)

        then:
        if (excluded) {
            1 * details.notFound()
        } else {
            0 * details.notFound()
        }


        when:
        descriptor = new DefaultRepositoryContentDescriptor({ "my-repo" }, new VersionParser())
        descriptor."include$method"(expr)

			apiserver_envelope_encryption_kms_operations_latency_seconds_bucket{grpc_status_code="NotFound",method_name="/v2alpha1.KeyManagementService/Encrypt",provider_name="providerName",le="0.0016"} 0

            }
            return false;
        }

        public DynamicInvokeResult getProperty(String name) {
            if (!includeProperties) {
                return DynamicInvokeResult.notFound();
            }

            maybeAddCallInterceptionHooksToMetaclass(name);
            MetaClass metaClass = getMetaClass();

            // First look for a property known to the meta-class

            if (extension != null) {
                return DynamicInvokeResult.found(extension);
            }
            if (plugins == null) {
                return DynamicInvokeResult.notFound();
            }
            for (Object object : plugins.values()) {
                DynamicObject dynamicObject = asDynamicObject(object).withNotImplementsMissing();

        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
        '500':
          $ref: '#/components/responses/InternalServerError'

  /documents/all:
    get:
      tags:
        - search
      summary: Finds all documents by query

		// the default criteria for dns, but then has a
		// non-standard but redundant notfound=return for the
		// files.
		{
			name:   "debian_squeeze",
			c:      &conf{},
			resolv: defaultResolvConf,
			nss:    nssStr(t, "hosts: dns [success=return notfound=continue unavail=continue tryagain=continue] files [notfound=return]"),
			hostTests: []nssHostTest{
				{"x.com", "myhostname", hostLookupDNSFiles},

		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "nf":
			z.NotFound, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "NotFound")
				return
			}
		case "e":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Err")
					return
				}

      internal::FindNodeAtPath(function_path, bundle_.saved_object_graph());
  if (!node.has_value()) {
    return errors::NotFound("No saved object found at path ", function_path);
  }

  *function = revived_objects_.concrete_functions.Find(*node);
  if (*function == nullptr) {
    return errors::NotFound("No function found at path ", function_path);
  }

  return Status();
}

Status TFSavedModelAPI::GetFunctions(

func checkNodeIPs(expected sets.Set[string], actual []net.IP) error {
	notFound := expected.Clone()
	extra := sets.New[string]()
	for _, ip := range actual {
		str := ip.String()
		if notFound.Has(str) {
			notFound.Delete(str)
		} else {
			extra.Insert(str)
		}
	}
	if len(notFound) != 0 || len(extra) != 0 {
		return fmt.Errorf("not found: %v, extra: %v", notFound.UnsortedList(), extra.UnsortedList())
	}
	return nil
}

            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) {