}
        return descendingMap;
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> firstEntry() {
      synchronized (mutex) {
        return nullableSynchronizedEntry(delegate().firstEntry(), mutex);
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> floorEntry(K key) {
      synchronized (mutex) {

     * @param map the sequenced map
     * @return the first entry, or null if the map is empty
     * @since Java 21
     */
    public static <K, V> Map.Entry<K, V> firstEntry(final SequencedMap<K, V> map) {
        return map.isEmpty() ? null : map.firstEntry();
    }

    /**
     * Returns the last entry of a sequenced map.
     *
     * @param <K> the key type
     * @param <V> the value type

    {
      Entry<Integer, String> entry = unmod.higherEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.firstEntry();
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.lastEntry();

    {
      Entry<Integer, String> entry = unmod.higherEntry(2);
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.firstEntry();
      assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    }
    {
      Entry<Integer, String> entry = unmod.lastEntry();

        long firstRetry = state.getNextRetryTime();
        state.incrementRetry();

        long secondRetry = state.getNextRetryTime();
        state.incrementRetry();

        long thirdRetry = state.getNextRetryTime();

        // Should have exponential backoff
        assertTrue(secondRetry > firstRetry);
        assertTrue(thirdRetry > secondRetry);
    }