List<Short> one = Arrays.asList((short) 1);
    assertThat(Shorts.toArray(one)).isEqualTo(ARRAY1);

    short[] array = {(short) 0, (short) 1, (short) 3};

    List<Short> three = Arrays.asList((short) 0, (short) 1, (short) 3);
    assertThat(Shorts.toArray(three)).isEqualTo(array);

    assertThat(Shorts.toArray(Shorts.asList(array))).isEqualTo(array);
  }

  public void testToArray_threadSafe() {

   *       take each of the servers offline, {@code consistentHash} will be a poor fit: It provides
   *       no way for you to specify which of the three buckets is disappearing. Thus, if your
   *       buckets change from {@code [alpha, bravo, charlie]} to {@code [bravo, charlie]}, it will

    List<Float> one = Arrays.asList(1.0f);
    assertThat(Floats.toArray(one)).isEqualTo(ARRAY1);

    float[] array = {0.0f, 1.0f, 3.0f};

    List<Float> three = Arrays.asList(0.0f, 1.0f, 3.0f);
    assertThat(Floats.toArray(three)).isEqualTo(array);

    assertThat(Floats.toArray(Floats.asList(array))).isEqualTo(array);
  }

  public void testToArray_threadSafe() {

    assertThat(Ints.toArray(one)).isEqualTo(ARRAY1);

    int[] array = {(int) 0, (int) 1, (int) 0xdeadbeef};

    List<Integer> three = Arrays.asList((int) 0, (int) 1, (int) 0xdeadbeef);
    assertThat(Ints.toArray(three)).isEqualTo(array);

    assertThat(Ints.toArray(Ints.asList(array))).isEqualTo(array);
  }

  public void testToArray_threadSafe() {

    List<Float> one = Arrays.asList(1.0f);
    assertThat(Floats.toArray(one)).isEqualTo(ARRAY1);

    float[] array = {0.0f, 1.0f, 3.0f};

    List<Float> three = Arrays.asList(0.0f, 1.0f, 3.0f);
    assertThat(Floats.toArray(three)).isEqualTo(array);

    assertThat(Floats.toArray(Floats.asList(array))).isEqualTo(array);
  }

  public void testToArray_threadSafe() {

    Iterator<String> iterator = asList("one", "two", "three", "four", "five").iterator();
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterator));
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("expected one element but was: <one, two, three, four, five>");
  }

      cp >>>= 2;
      dest[2] = upperHexDigits[cp & 0xF];
      cp >>>= 4;
      dest[1] = upperHexDigits[0xC | cp];
      return dest;
    } else if (cp <= 0xffff) {
      // Three byte UTF-8 characters [cp >= 0x800 && cp <= 0xffff]
      // Start with "%E-%--%--" and fill in the blanks
      char[] dest = new char[9];
      dest[0] = '%';
      dest[1] = 'E';
      dest[3] = '%';

        // and overlong 2-byte form.
        if (byte1 < (byte) 0xC2 || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else if (byte1 < (byte) 0xF0) {
        // Three-byte form.
        if (index + 1 >= end) {
          return false;
        }
        int byte2 = bytes[index++];
        if (byte2 > (byte) 0xBF
            // Overlong? 5 most significant bits must not all be zero.

        final String message = "Parameter order test";
        final Exception cause = new RuntimeException("Test cause");

        // Execute with three parameters
        final InvalidQueryException exception3Params = new InvalidQueryException(messageCode, message, cause);

        // Execute with two parameters

You can build your own connection spec with a custom set of TLS versions and cipher suites. For example, this configuration is limited to three highly-regarded cipher suites. Its drawback is that it requires Android 5.0+ and a similarly current webserver.

```java
ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)