if isFile {
		return ErrFileClosing
	}
	return ErrNetClosing
}

// ErrDeadlineExceeded is returned for an expired deadline.
// This is exported by the os package as os.ErrDeadlineExceeded.
var ErrDeadlineExceeded error = &DeadlineExceededError{}

// DeadlineExceededError is returned for an expired deadline.
type DeadlineExceededError struct{}

// Implement the net.Error interface.

		ttl  float64
		time time.Time
	}{
		{
			name: "ttl valid",
			ttl:  30,
			time: t0.Add(time.Second * 30),
		},
		{
			name: "ttl almost expired",
			ttl:  2,
			time: t0.Add(time.Second * 58),
		},
		{
			name: "ttl just expired",
			ttl:  0,
			time: t0.Add(time.Second * 60),
		},
		{
			name: "ttl-invalid",
			ttl:  -30,
			time: t0.Add(time.Second * 90),
		},
	}

	}
	// Create an expired JWT token
	expiredStr := strconv.FormatInt(time.Now().Add(-time.Hour).Unix(), 10)
	expiredClaims := `{"iss": "` + server.URL + `", "aud": ["baz.svc.id.goog"], "sub": "system:serviceaccount:bar:foo", "exp": ` + expiredStr + `}`
	expiredToken, err := generateJWT(&key, []byte(expiredClaims))
	if err != nil {
		t.Fatalf("failed to generate an expired JWT: %v", err)
	}

					}
				}
			} else {
				// the certificate is expired
				if now.After(curr.Leaf.NotAfter) {
					if clientCertificateManager.ServerHealthy() {
						klog.ErrorS(nil, "The currently active client certificate has expired and the server is responsive, exiting.")
						os.Exit(1)
					} else {

    }

    /**
     * タイマーを再開始します。
     */
    public void restart() {
        status = ACTIVE;
        startTime = System.currentTimeMillis();
    }

    void expired() {
        timeoutTarget.expired();
    }

		}
	}
}

func TestCertExpired(t *testing.T) {
	testCases := map[string]struct {
		filepath string
		expected bool
	}{
		"Expired Cert": {
			filepath: "../testdata/expired-cert.pem",
			expected: true,
		},
		"Not Expired Cert": {
			filepath: "../testdata/notexpired-cert.pem",
			expected: false,
		},
	}
	for id, tc := range testCases {
		t.Run(id, func(t *testing.T) {

		tmpl.NotAfter = signerNotAfter
	}

	if !tmpl.NotBefore.Before(signerNotAfter) {
		return fmt.Errorf("the signer has expired: NotAfter=%v", signerNotAfter)
	}

	if !now.Before(signerNotAfter) {
		return fmt.Errorf("refusing to sign a certificate that expired in the past: NotAfter=%v", signerNotAfter)
	}

	return nil
}

var keyUsageDict = map[capi.KeyUsage]x509.KeyUsage{

	/* 27 */ {_SigNotify + _SigDefault + _SigIgn, "SIGTTOU: background tty write attempted"},
	/* 28 */ {_SigNotify, "SIGVTALRM: virtual timer expired"},
	/* 29 */ {_SigNotify + _SigUnblock, "SIGPROF: profiling timer expired"},
	/* 30 */ {_SigNotify, "SIGXCPU: exceeded cpu limit"},
	/* 31 */ {_SigNotify, "SIGXFSZ: exceeded file size limit"},
	/* 32 */ {_SigNotify, "SIGWAITING: reserved signal no longer used by"},

                    break;
                }
            }
            if (LOGGER.isDebugEnabled() && !toExpire.isEmpty()) {
                // TODO Only log expired workers count, log their "identity" once they are nameable/describable
                LOGGER.debug("Worker Daemon(s) expired to free some system memory {}", toExpire.size());
            }
            if (notExpirable > 0) {

	now := time.Now()
	if ca.Now != nil {
		now = ca.Now()
	}

	nbf := now.Add(-ca.Backdate)
	if !nbf.Before(ca.Certificate.NotAfter) {
		return nil, fmt.Errorf("the signer has expired: NotAfter=%v", ca.Certificate.NotAfter)
	}

	cr, err := x509.ParseCertificateRequest(crDER)
	if err != nil {
		return nil, fmt.Errorf("unable to parse certificate request: %v", err)
	}