} else if (type == Byte.class) {
            return ByteConversionUtil.toByte(o);
        }
        return o;
    }

    /**
     * Converts to the wrapper type corresponding to the specified primitive type.
     *
     * @param type
     *            Primitive type
     * @param o
     *            Source object
     * @return Object converted to the wrapper type corresponding to the specified primitive type

// dataUsageHash is the hash type used.
type dataUsageHash string

// sizeHistogramV1 is size histogram V1, which has fewer intervals esp. between
// 1024B and 1MiB.
type sizeHistogramV1 [dataUsageBucketLenV1]uint64

// sizeHistogram is a size histogram.
type sizeHistogram [dataUsageBucketLen]uint64

// versionsHistogram is a histogram of number of versions in an object.
type versionsHistogram [dataUsageVersionLen]uint64

     */
    public static Byte toByte(final Object o) {
        return toByte(o, null);
    }

    /**
     * Converts to {@link Byte}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Byte}
     */
    public static Byte toByte(final Object o, final String pattern) {
        if (o == null) {

    // Verify the peer received what was expected.
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_PING)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_HEADERS)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_PING)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_DATA)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_RST_STREAM)
  }

  @Test fun outgoingWritesAreBatched() {

        // array.
        while (mid > -1 && this[mid] != '\n'.code.toByte()) {
          mid--
        }
        mid++

        // Now look for the ending '\n'.
        var end = 1
        while (this[mid + end] != '\n'.code.toByte()) {
          end++
        }
        val publicSuffixLength = mid + end - mid

     * <p>
     * If <code>type</code> is not a parameterized type, <code>null</code> is returned.
     * </p>
     *
     * @param type
     *            the type to analyze
     * @return the array of type arguments for the specified type
     * @see ParameterizedType#getActualTypeArguments()
     */
    public static Type[] getGenericParameters(final Type type) {
        if (type instanceof ParameterizedType) {

        throw new IllegalArgumentException("No type mapping from " + fromClass + " to " + to);
      }
    }.visit(from);
  }

  /**
   * Resolves all type variables in {@code type} and all downstream types and returns a
   * corresponding type with type variables resolved.
   */
  public Type resolveType(Type type) {
    checkNotNull(type);
    if (type instanceof TypeVariable) {

| `minio_api_requests_rejected_header_total`     | Total number of requests rejected for invalid header. <br><br>Type: counter    | `type`, `pool_index`, `server`               |
| `minio_api_requests_rejected_timestamp_total`  | Total number of requests rejected for invalid timestamp. <br><br>Type: counter | `type`, `pool_index`, `server`               |

pkg p1, type S struct, PublicTime Time
pkg p1, type S2 struct
pkg p1, type S2 struct, Extra bool
pkg p1, type S2 struct, embedded S
pkg p1, type S2 struct, embedded S //deprecated
pkg p1, type SI struct
pkg p1, type SI struct, I int
pkg p1, type T struct
pkg p1, type TPtrExported struct
pkg p1, type TPtrExported struct, embedded *Embedded
pkg p1, type TPtrUnexported struct
pkg p1, type Time struct

        String scope = "testScope";
        when(nameServiceClient.getNbtByName(host, type, scope)).thenThrow(new UnknownHostException("Host not found"));

        // Act & Assert
        assertThrows(UnknownHostException.class, () -> nameServiceClient.getNbtByName(host, type, scope));
        verify(nameServiceClient, times(1)).getNbtByName(host, type, scope);
    }

    @Test