return false
	}
	if deprecatedMajor == currentMajor && deprecatedMinor > currentMinor {
		return false
	}
	return true
}

// RemovedRelease returns the major/minor version in which the given object is unavailable (in the form "<major>.<minor>")
// if the object implements APILifecycleRemoved() to indicate a non-zero removal version, and returns an empty string otherwise.
func RemovedRelease(obj runtime.Object) string {

	case StatusUnavailableForLegalReasons:
		return "Unavailable For Legal Reasons"
	case StatusInternalServerError:
		return "Internal Server Error"
	case StatusNotImplemented:
		return "Not Implemented"
	case StatusBadGateway:
		return "Bad Gateway"
	case StatusServiceUnavailable:
		return "Service Unavailable"
	case StatusGatewayTimeout:
		return "Gateway Timeout"

        and:
        registry.addDefaultToolChains()

        then:
        registry.asList() == [configuredToolChain, defaultToolChain]
    }

    def "provides unavailable tool chain when no tool chain available for requested platform"() {
        unavailableToolChain("test", "nope")
        unavailableToolChain("test2", "not me")
        unavailableToolChain("test3", "not me either")

        return formatter.toString();
    }

    @Override
    public void explain(DiagnosticsVisitor visitor) {
        reason.explain(visitor);
    }

    public ToolChainAvailability unavailable(String unavailableMessage) {
        if (reason == null) {
            reason = new FixedMessageToolSearchResult(unavailableMessage);
        }
        return this;
    }

    os.flush();
  }

  std::string filepath = DumpMlirOpToFile("module", module_ref.get());
  ASSERT_NE(filepath, "(TF_DUMP_GRAPH_PREFIX not specified)");
  ASSERT_NE(filepath, "LOG(INFO)");
  ASSERT_NE(filepath, "(unavailable)");

  Env* env = Env::Default();
  std::string file_txt_module;
  TF_ASSERT_OK(ReadFileToString(env, filepath, &file_txt_module));
  EXPECT_EQ(file_txt_module, expected_txt_module);
}

        when:
        run "properties", "-q", "--property=version"
        then:
        outputContains 'version: 1.2.3'
        outputDoesNotContain 'org.gradle.api'
    }

    def "lists unavailable project property"() {
        when:
        run "properties", "-q", "--property=nonexistent"
        then:
        outputContains 'nonexistent: null'
    }

        1       | 2               | 4          | ["1 busy", "2 incompatible", "4 stopped"]
    }

    def "starting message contains subsequent builds message given no unavailable daemons"() {
        given:
        def message = DaemonStartupMessage.generate(0, 0, 0)

        expect:
        message.contains(DaemonStartupMessage.STARTING_DAEMON_MESSAGE)

          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
            "num_retries": 2,
            "retry_host_predicate": [
             {
              "name": "envoy.retry_host_predicates.previous_hosts",
              "typed_config": {

public interface WindowsComponentLocator<T> {
    /**
     * Locates a component to use.
     *
     * @param candidate The install dir to use. Can be null.
     * @return A result containing the best component, or an unavailable result that explains why the lookup failed
     */
    SearchResult<T> locateComponent(@Nullable File candidate);

    /**

    ExternalResourceMetaData getExternalResourceMetaData();

    /**
     * Null safe shortcut for getExternalResourceMetaData().getLastModified();
     *
     * @return The external last modified, or null if unavailable.
     */
    Date getExternalLastModified();