<postConstruct name="addDesignJspFileName">
			<arg>"error"</arg>
			<arg>"error/error.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorNotFound"</arg>
			<arg>"error/notFound.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorSystem"</arg>
			<arg>"error/system.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">

	klog.InfoS("Swap is on", "/proc/swaps contents", procSwapsStr)
	return len(procSwapsLines) > 1
}

// IsSwapOn detects whether swap in enabled on the system by inspecting
// /proc/swaps. If the file does not exist, an os.NotFound error will be returned.
// If running on windows, swap is assumed to always be false.
func IsSwapOn() (bool, error) {
	isSwapOnHelper := func() (bool, error) {
		if sysruntime.GOOS == "windows" {
			return false, nil

			ErrorTypeNotSupported,
		},
		{
			func() *Error { return Duplicate(NewPath("f"), "v") },
			ErrorTypeDuplicate,
		},
		{
			func() *Error { return NotFound(NewPath("f"), "v") },
			ErrorTypeNotFound,
		},
		{
			func() *Error { return Required(NewPath("f"), "d") },
			ErrorTypeRequired,
		},
		{

// last in the list.
func (c nssCriterion) standardStatusAction(last bool) bool {
	if c.negate {
		return false
	}
	var def string
	switch c.status {
	case "success":
		def = "return"
	case "notfound", "unavail", "tryagain":
		def = "continue"
	default:
		// Unknown status
		return false
	}
	if last && c.action == "return" {
		return true
	}
	return c.action == def
}

            return PluginResolutionResult.found(pluginResolution);
        } else {
            return PluginResolutionResult.notFound("Classpath", "Plugin with id '" + pluginId + "' not found.");
        }
    }

    private boolean isPresentOnClasspath(PluginId pluginId) {

            }
        }
        if (resolvableArtifact != null) {
            result.resolved(resolvableArtifact);
        } else {
            result.notFound(artifact.getId());
        }
    }

    public ValueCalculator<File> resolveArtifactLater(ComponentArtifactMetadata artifact) {

        if (plugin == null) {
            String classpathStr = injectedClasspath.getAsFiles().stream().map(File::getAbsolutePath).collect(Collectors.joining(File.pathSeparator));
            return PluginResolutionResult.notFound(getDescription(), "classpath: " + classpathStr);
        } else {
            return PluginResolutionResult.found(new InjectedClasspathPluginResolution(plugin));
        }
    }

        resolver.remoteAccess.resolveArtifact(artifact, ImmutableModuleSources.of(moduleSource), artifactResult)

        then:
        1 * artifactResolver.resolveArtifact(artifact, _) >> null
        1 * artifactResult.notFound(artifactIdentifier)
        0 * artifactResult._
        0 * artifactResolver._
    }

    def reportsFailedArtifactResolveResult() {
        when:

  mutex_lock lock(mu_);

  if (auto it = cluster_compile_stats_.find(function.name());
      it != cluster_compile_stats_.end()) {
    return it->second;
  }

  return errors::NotFound("Couldn't find compilation stats for cluster: ",
                          function.name());
}

void DeviceCompilationProfiler::RegisterExecution(
    const NameAttrList& function) {
  mutex_lock lock(mu_);

          absl::StrCat(entry.hlo_module().name(), "_altered"));
      TF_RETURN_IF_ERROR(WriteBinaryProto(env, file_path, entry));
      altered = true;
    }
  }

  if (!altered) {
    return errors::NotFound(
        "Did not find any persistent XLA compilation cache entries to alter.");
  }
  return absl::OkStatus();
}