var addr string

	if enableXFFHeader {
		if fwd := r.Header.Get(xForwardedFor); fwd != "" {
			// Only grab the first (client) address. Note that '192.168.0.1,
			// 10.1.1.1' is a valid key for X-Forwarded-For where addresses after
			// the first may represent forwarding proxies earlier in the chain.
			s := strings.Index(fwd, ", ")
			if s == -1 {
				s = len(fwd)
			}
			addr = fwd[:s]
		}

  @Test public void getFailsWithoutAdditionalCert() throws IOException {
    OkHttpClient client = new OkHttpClient();

    boolean androidMorEarlier = Build.VERSION.SDK_INT <= 23;
    try {
      sendRequest(client, "https://valid-isrgrootx1.letsencrypt.org/robots.txt");
      if (androidMorEarlier) {
        fail();
      }
    } catch (SSLHandshakeException sslhe) {
      assertTrue(androidMorEarlier);
    }
  }

            // No more pages
            this.done = true;
            return false;
        }

        @Override
        protected FileEntry[] getResults() {
            // Return current page if valid
            if (staticPages != null && pageIdx >= 0 && pageIdx < staticPages.size()) {
                return staticPages.get(pageIdx);
            }
            return new FileEntry[0];
        }

        verify(smbFileHandle, times(1)).getTree();
    }

    /**
     * Test isValid() when the handle is valid.
     */
    @Test
    void testIsValid_whenValid() {
        when(smbFileHandle.isValid()).thenReturn(true);
        assertTrue(smbFileHandle.isValid(), "isValid should return true when the handle is valid.");
        verify(smbFileHandle, times(1)).isValid();
    }

    /**

// Tests if the directory and file creations happen with proper umask.
func TestIsValidUmaskVol(t *testing.T) {
	tmpPath := t.TempDir()
	testCases := []struct {
		volName       string
		expectedUmask int
	}{
		{"is-this-valid", getUmask()},
	}
	testCase := testCases[0]

	// Initialize a new xlStorage layer.
	disk, err := newLocalXLStorage(tmpPath)
	if err != nil {
		t.Fatalf("Initializing xlStorage failed with %s.", err)
	}

   *
   * <p><b>Java 8+ users:</b> use {@link Long#parseUnsignedLong(String)} instead.
   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code long}
   *     value
   * @throws NullPointerException if {@code string} is null (in contrast to {@link
   *     Long#parseLong(String)})
   */
  @CanIgnoreReturnValue

                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

вы получите текстовую версию:

```
Validation errors:
Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
```

| token          | string     | Token from the AssumeRoleWithCustomToken call for external verification |

### Response

If the token is valid and access is approved, the plugin must return a `200` (OK) HTTP status code.

A `200 OK` Response should have `application/json` content-type and body with the following structure:

```json
{
    "user": <string>,

| Params        | Value                                              |
| :--           | :--                                                |
| *Type*        | *Integer*                                          |
| *Valid Range* | *Minimum value of 900. Maximum value of 31536000.* |
| *Required*    | *No*                                               |

### Policy

  }

  /**
   * Ensures that valid flag combinations appear visually correct, and invalid show in hex.  This
   * also demonstrates how sparse the lookup table is.
   */
  @Test
  fun allFormattedFlagsWithValidBits() {
    val formattedFlags = mutableListOf<String>() // Highest valid flag is 0x20.
    for (i in 0..0x3f) formattedFlags.add(formatFlags(TYPE_HEADERS, i))