"Expiration": "2019-02-20T19:56:59-08:00",
        "AccessKeyId": "K9DTIMUVZXEXJL3ATUOY"
    }
}
```

### Testing an example with `assume-role.go`

The included program in this directory can also be used for testing:

``` shell
$ go run assume-role.go -u foobar -p foo12345 -d
Only displaying credentials:
AccessKeyID: 27YDRYEM0S9B44AJJX9X
SecretAccessKey: LHPdHeaLiYk+pDZ3hgN3sdwXpJC2qbhBfZ8ii9Z3

There are, however, times when we cannot maintain complete compatibility.
If code depends on buggy (including insecure) behavior,
then fixing the bug will break that code.
New features can also have similar impacts:
enabling the HTTP/2 use by the HTTP client broke programs
connecting to servers with buggy HTTP/2 implementations.
These kinds of changes are unavoidable and

  ): Mapping =
    Mapping(
      sourceCodePoint0 = sourceCodePoint0,
      sourceCodePoint1 = sourceCodePoint1,
      type = TYPE_MAPPED,
      mappedTo =
        Buffer()
          .also {
            for (cp in mappedToCodePoints) {
              it.writeUtf8CodePoint(cp)
            }
          }.readByteString(),
    )

    "denyOnly": false
  }
}
```

</details>

The response expected by MinIO, is a JSON body with a boolean:

```json
{
    "result": true
}
```

The following structure is also accepted:

```json
{
    "result": {
        "allow": true
    }
}
```

  //    (hypothetical) unsafe read by our caller. Note: adding 'volatile' does not fix this issue,
  //    it would just add an edge such that if done() observed non-null, then it would also
  //    definitely observe all earlier writes, but we still have no guarantee that done() would see
  //    the initial write (just stronger guarantees if it does).
  //

  internal var allocationLimit = 1
    private set

  /** Current calls carried by this connection. */
  val calls = mutableListOf<Reference<RealCall>>()

  /** Timestamp when `allocations.size()` reached zero. Also assigned upon initial connection. */
  var idleAtNs = Long.MAX_VALUE

  /**
   * Returns true if this is an HTTP/2 connection. Such connections can be used in multiple HTTP
   * requests simultaneously.
   */

/**
 * A Windows SID is a numeric identifier used to represent Windows
 * accounts. SIDs are commonly represented using a textual format such as
 * <code>S-1-5-21-1496946806-2192648263-3843101252-1029</code> but they may
 * also be resolved to yield the name of the associated Windows account
 * such as <code>Administrators</code> or <code>MYDOM\alice</code>.
 * <p>
 * Consider the following output of <code>examples/SidLookup.java</code>:
 *
 * <pre>

    /**
     * This is an alternative to the <code>java.lang.Integer.toHexString</code>
     * method. It is an efficient relative that also will pad the left side so
     * that the result is <code>size</code> digits.
     *
     * @param val the integer value to convert to hexadecimal

     * The {@link PathType} keys identify, for example, {@code --class-path} or {@code --module-path} options.
     * In the case of Java tools, the map may also contain {@code --patch-module} options, which are
     * {@linkplain org.apache.maven.api.JavaPathType#patchModule(String) handled in a special way}.
     *
     * <h4>Design note</h4>

     * useful regardless of this renderer's needs, since now there will be a link embedded in the report
     * to quickly open the changes file.  By then we can also regex that path out of the description
     * in order to create a changes {@link File} for further use in this class.
     *
     * @param data the report data containing a description to parse