"type": "string"
          },
          "message": {
            "description": "A human-readable description of the cause of the error.  This field may be presented as-is to a reader.",
            "type": "string"
          },
          "reason": {
            "description": "A machine-readable description of the cause of the error. If this value is empty there is no information available.",

which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although...

	0x0000000112000001, 0x0000000106000001, 0x0000000101400001, 0x000000010a000001,
	0x0000000102020001,
}

// regionInclusionNext marks, for each entry in regionInclusionBits, the set of
// all groups that are reachable from the groups set in the respective entry.
// Size: 73 bytes, 73 elements
var regionInclusionNext = [73]uint8{
	// Entry 0 - 3F
	0x3e, 0x3f, 0x0b, 0x0b, 0x40, 0x01, 0x0b, 0x01,

}

// A countedConn is a net.Conn that decrements an atomic counter when finalized.
type countedConn struct {
	net.Conn
}

// A countingDialer dials connections and counts the number that remain reachable.
type countingDialer struct {
	dialer      net.Dialer
	mu          sync.Mutex
	total, live int64
}

func (d *countingDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {

or <code>*s</code>, and returns the field offset in bytes relative to the struct's address.
If <code>f</code> is an <a href="#Struct_types">embedded field</a>, it must be reachable
without pointer indirections through fields of the struct.
For a struct <code>s</code> with field <code>f</code>:
</p>

<pre>

		vetFlags = []string{"-unsafeptr=false"}

		// Also turn off -unreachable checks during go test.
		// During testing it is very common to make changes
		// like hard-coded forced returns or panics that make
		// code unreachable. It's unreasonable to insist on files
		// not having any unreachable code during "go test".
		// (buildall.bash still has -unreachable enabled
		// for the overall whole-tree scan.)

		t.Skip("Skipping test on Windows.")
	}
	fakeNow := metav1.Date(2017, 1, 1, 12, 0, 0, 0, time.UTC)

	fakeNodeHandler := &testutil.FakeNodeHandler{
		Existing: []*v1.Node{
			// Unreachable Taint with effect 'NoExecute' should be applied to this node.
			{
				ObjectMeta: metav1.ObjectMeta{
					Name:              "node0",
					CreationTimestamp: metav1.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC),

// human-readable approximation.
func translateMicroTimestampSince(timestamp metav1.MicroTime) string {
	if timestamp.IsZero() {
		return "<unknown>"
	}

	return duration.HumanDuration(time.Since(timestamp.Time))
}

// translateTimestampSince returns the elapsed time since timestamp in
// human-readable approximation.

          </description>
          <type>String</type>
        </field>
        <field>
          <name>name</name>
          <version>4.0.0+</version>
          <description>Human readable name of the repository.</description>
          <type>String</type>
        </field>
        <field>
          <name>url</name>
          <version>4.0.0+</version>
          <required>true</required>

  /** https://github.com/square/okhttp/issues/442  */
  @Test
  fun tlsTimeoutsNotRetried() {
    enableTls()
    server.enqueue(MockResponse(socketPolicy = NoResponse))
    server.enqueue(MockResponse(body = "unreachable!"))
    client =
      client.newBuilder()
        .readTimeout(Duration.ofMillis(100))
        .build()
    val request = Request.Builder().url(server.url("/")).build()