desc:      "valid ipv4 with port",
			argc:      "blah --ipport=0.0.0.0:8080",
			expectVal: "0.0.0.0:8080",
		},
		{
			desc:      "invalid ipv4 with invalid port",
			argc:      "blah --ipport=0.0.0.0:invalidport",
			expectErr: true,
			expectVal: defaultIPPort,
		},
		{
			desc:      "invalid IP with port",
			argc:      "blah --ipport=invalidip:8080",
			expectErr: true,
			expectVal: defaultIPPort,
		},

      requestBuilder.url("ftp://hostname/path")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Expected URL scheme 'http' or 'https' but was 'ftp'")
    }
  }

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("http://localhost:65536/")
    }.also { expected ->

Keys in this directory are generated for testing purposes only.

In this pr validCert(mycertvalid.crt):
```
Validity
Not Before: Apr 26 23:26:52 2017 GMT
Not After : Apr 2 23:26:52 2117 GMT
```



InvalidCert(mycertinvalid.crt):
```
Validity
Not Before: Dec 16 06:46:25 2014 GMT
Not After : Dec 16 06:46:25 2015 GMT

    client = TestClient(app, base_url="http://subdomain.example.com")
    response = client.get("/")
    assert response.status_code == 200, response.text
    client = TestClient(app, base_url="http://invalidhost")
    response = client.get("/")

		k8sCaCertFile     string
		secretNames       []string
		dnsNames          []string
		serviceNamespaces []string

		secretName      string
		secretNameSpace string

		invalidCert     bool
		expectFail      bool
		certificateData []byte
	}{
		{
			name:              "read signed cert should succeed",
			gracePeriodRatio:  0.6,
			k8sCaCertFile:     "./test-data/example-ca-cert.pem",

   * @throws IllegalArgumentException if {@code host} contains a port number, or {@code port} is out
   *     of range.
   */
  public static HostAndPort fromParts(String host, int port) {
    checkArgument(isValidPort(port), "Port out of range: %s", port);
    HostAndPort parsedHost = fromString(host);
    checkArgument(!parsedHost.hasPort(), "Host has a port: %s", host);

   * @throws IllegalArgumentException if {@code host} contains a port number, or {@code port} is out
   *     of range.
   */
  public static HostAndPort fromParts(String host, int port) {
    checkArgument(isValidPort(port), "Port out of range: %s", port);
    HostAndPort parsedHost = fromString(host);
    checkArgument(!parsedHost.hasPort(), "Host has a port: %s", host);

        result.executionReasons == ["No history is available."]
    }

    def "out of date when work fails validation"() {
        given:
        execute(unitOfWork)

        def invalidWork = builder
            .withValidator { context ->
                context
                    .forType(UnitOfWork, false)
                    .visitPropertyProblem {

			cert:        testCert,
			now:         time.Date(2017, time.August, 24, 16, 0, 0, 40, time.UTC),
			expectedErr: "got a certificate that should be renewed now",
		},
		"Invalid cert pem": {
			cert:        []byte(`INVALIDCERT`),
			now:         time.Date(2017, time.August, 23, 21, 0, 0, 40, time.UTC),
			expectedErr: "invalid PEM encoded certificate",
		},
	}

	cu := NewCertUtil(50) // Grace period percentage is set to 50

	{err: ObjectNotFound{}, errCode: ErrNoSuchKey},
	{err: ObjectNameInvalid{}, errCode: ErrInvalidObjectName},
	{err: InvalidUploadID{}, errCode: ErrNoSuchUpload},
	{err: InvalidPart{}, errCode: ErrInvalidPart},
	{err: InsufficientReadQuorum{}, errCode: ErrSlowDownRead},
	{err: InsufficientWriteQuorum{}, errCode: ErrSlowDownWrite},
	{err: InvalidUploadIDKeyCombination{}, errCode: ErrNotImplemented},