assertThat(expected).hasCauseThat().isEqualTo(cause);

    Object newValue = new Object();
    valueRef.set(newValue);
    assertSame(newValue, cache.getUnchecked(new Object()));
  }

  public void testGetUnchecked_unchecked() {
    RuntimeException cause = new RuntimeException();
    AtomicReference<Object> valueRef = new AtomicReference<>();

    testRotate(new byte[] {1, 2}, -1, new byte[] {2, 1});
    testRotate(new byte[] {1, 2}, -2, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 0, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 1, new byte[] {2, 1});
    testRotate(new byte[] {1, 2}, 2, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 3, new byte[] {2, 1});

    testRotate(new byte[] {1, 2, 3}, -5, new byte[] {3, 1, 2});

        // When/Then
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException((String) null);
            assertNull(exception.getMessage());
        });

        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException(null, new RuntimeException());
            assertNull(exception.getMessage());
        });
    }

    @Test

    testRotate(new double[] {1, 2}, -3, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 0, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, 2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 3, new double[] {2, 1});

  public void testRotate() {
    testRotate(new char[] {}, -1, new char[] {});
    testRotate(new char[] {}, 0, new char[] {});
    testRotate(new char[] {}, 1, new char[] {});

    testRotate(new char[] {'1'}, -2, new char[] {'1'});
    testRotate(new char[] {'1'}, -1, new char[] {'1'});
    testRotate(new char[] {'1'}, 0, new char[] {'1'});
    testRotate(new char[] {'1'}, 1, new char[] {'1'});

    testRotate(new double[] {1, 2}, -3, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 0, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, 2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 3, new double[] {2, 1});

     */
    public static <KEY, VALUE> Maps<KEY, VALUE> concurrentHashMap(final KEY key, final VALUE value) {
        return new Maps<>(new ConcurrentHashMap<KEY, VALUE>()).$(key, value);
    }

    /**
     * Returns a {@literal Maps} for constructing a {@link HashMap} with the specified key and value.
     *

    testRotate(new long[] {1, 2}, -1, new long[] {2, 1});
    testRotate(new long[] {1, 2}, -2, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 0, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 1, new long[] {2, 1});
    testRotate(new long[] {1, 2}, 2, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 3, new long[] {2, 1});

    testRotate(new long[] {1, 2, 3}, -5, new long[] {3, 1, 2});

    testRotate(new short[] {1, 2}, -3, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 0, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, 2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 3, new short[] {2, 1});

    SomeCheckedException cause = new SomeCheckedException();
    SomeChainingException exception = new SomeChainingException(new SomeChainingException(cause));
    assertSame(cause, getRootCause(exception));
  }

  public void testGetRootCause_loop() {
    Exception cause = new Exception();
    Exception exception = new Exception(cause);
    cause.initCause(exception);
    IllegalArgumentException expected =