ImmutableList.of(
            Striped.lazyWeakLock(Integer.MAX_VALUE),
            Striped.lazyWeakSemaphore(Integer.MAX_VALUE, Integer.MAX_VALUE),
            Striped.lazyWeakReadWriteLock(Integer.MAX_VALUE))) {
      for (int i = 0; i < 3; i++) {
        // doesn't throw exception
        Object unused = striped.getAt(Integer.MAX_VALUE - i);
      }
    }
  }

        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testMaximumValues() {
            request.setOffset(Long.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);
            request.setWriteFlags(Integer.MAX_VALUE);
            request.setData(new byte[10], 0, 10);

            byte[] buffer = new byte[256];

   */
  public static int checkedCast(long value) {
    checkArgument((value >> Integer.SIZE) == 0, "out of range: %s", value);
    return (int) value;
  }

  /**
   * Returns the {@code int} value that, when treated as unsigned, is nearest in value to {@code
   * value}.
   *
   * @param value any {@code long} value
   * @return {@code 2^32 - 1} if {@code value >= 2^32}, {@code 0} if {@code value <= 0}, and {@code

 * limitations under the License.
 */

package com.google.common.collect;

import static com.google.common.truth.Truth.assertThat;
import static java.lang.Long.MAX_VALUE;
import static java.lang.Thread.currentThread;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

    while (h < input.size) {
      val m = input.minBy { if (it >= n) it else Int.MAX_VALUE }

      val increment = (m - n) * (h + 1)
      if (delta > Int.MAX_VALUE - increment) return false // Prevent overflow.
      delta += increment

      n = m

      for (c in input) {
        if (c < n) {
          if (delta == Int.MAX_VALUE) return false // Prevent overflow.
          delta++
        } else if (c == n) {

        assertEquals(24L, MemoryUtil.sizeOf(Integer.MAX_VALUE));
        assertEquals(24L, MemoryUtil.sizeOf(Long.MAX_VALUE));
        assertEquals(24L, MemoryUtil.sizeOf(Short.MAX_VALUE));
        assertEquals(24L, MemoryUtil.sizeOf(Float.MAX_VALUE));
        assertEquals(24L, MemoryUtil.sizeOf(Double.MAX_VALUE));
        assertEquals(24L, MemoryUtil.sizeOf(Byte.MAX_VALUE));
        assertEquals(16L, MemoryUtil.sizeOf(Boolean.TRUE));

   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of
   * self-loops incident to {@code node}).
   *
   * <p>If the count is greater than {@code Integer.MAX_VALUE}, returns {@code Integer.MAX_VALUE}.
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  int degree(N node);

  /**

	switch value := dbValue.(type) {
	case []byte:
		*es = EncryptedString(bytes.TrimPrefix(value, []byte("hello")))
	case string:
		*es = EncryptedString(strings.TrimPrefix(value, "hello"))
	default:
		return fmt.Errorf("unsupported data %#v", dbValue)
	}
	return nil
}

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);
            assertEquals(Integer.MAX_VALUE, response.getChunksWritten());
            assertEquals(Integer.MAX_VALUE, response.getChunkBytesWritten());
            assertEquals(Integer.MAX_VALUE, response.getTotalBytesWritten());
        }

    void testWriteInt4Various(int value) {
        byte[] dst = new byte[4];
        SessionServicePacket.writeInt4(value, dst, 0);

        assertEquals((byte) ((value >> 24) & 0xFF), dst[0]);
        assertEquals((byte) ((value >> 16) & 0xFF), dst[1]);
        assertEquals((byte) ((value >> 8) & 0xFF), dst[2]);
        assertEquals((byte) (value & 0xFF), dst[3]);
    }