V value = getValueNotInPopulatedMap();
    subMap.put(key, value);
    assertEquals(secondEntry.getValue(), value);
    assertEquals(map.get(key), value);
    assertThrows(IllegalArgumentException.class, () -> subMap.put(firstEntry.getKey(), value));
  }

  public void testTailMapRemoveThrough() {
    SortedMap<K, V> map;
    try {
      map = makePopulatedMap();

            return 0x0101;
        case FileInformation.FILE_STANDARD_INFO:
            return 0x0102;
        case FileInformation.FILE_ENDOFFILE_INFO:
            return 0x0104;
        }
        throw new IllegalArgumentException("Unsupported information level " + il);
    }

    @Override
    protected int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

        final String upper = typeStr.toUpperCase(Locale.ROOT);
        try {
            return StorageType.valueOf(upper);
        } catch (final IllegalArgumentException e) {
            logger.warn("Unknown storage type: {}, defaulting to S3_COMPAT", typeStr);
            return StorageType.S3_COMPAT;
        }
    }

   *     order the comparator should induce
   * @return the comparator described above
   * @throws NullPointerException if any of the provided values is null
   * @throws IllegalArgumentException if {@code valuesInOrder} contains any duplicate values
   *     (according to {@link Object#equals})
   */
  // TODO(kevinb): provide replacement
  public static <T> Ordering<T> explicit(List<T> valuesInOrder) {

          }

          @Override
          public final Throwable failureCause() {
            return delegate.failureCause();
          }
        };
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> new ServiceManager(Arrays.asList(service1, service2)));
    assertThat(expected).hasMessageThat().contains("started transitioning asynchronously");
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(ZERO)
  public void testPutWithSameValueFails() {
    getMap().put(k0(), v0());
    assertThrows(IllegalArgumentException.class, () -> getMap().put(k1(), v0()));
    // verify that the bimap is unchanged
    expectAdded(e0());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(ZERO)

    assertThrows(IllegalArgumentException.class, () -> Queues.newLinkedBlockingDeque(0));
    assertEquals(1, Queues.newLinkedBlockingDeque(1).remainingCapacity());
    assertEquals(11, Queues.newLinkedBlockingDeque(11).remainingCapacity());
  }

  public void testNewLinkedBlockingQueueCapacity() {
    assertThrows(IllegalArgumentException.class, () -> Queues.newLinkedBlockingQueue(0));

            list.set(to, element);
          } catch (UnsupportedOperationException e) {
            slowRemoveIfForRemainingElements(list, predicate, to, from);
            return true;
          } catch (IllegalArgumentException e) {
            slowRemoveIfForRemainingElements(list, predicate, to, from);
            return true;
          }
        }
        to++;
      }
    }

      K key = checkNotNull(entry.getKey());
      V previous = delegate.put(key, checkNotNull(entry.getValue()));
      if (throwIfDuplicateKeys && previous != null) {
        throw new IllegalArgumentException("duplicate key: " + key);
      }
    }
    this.delegate = Collections.unmodifiableMap(delegate);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override

   * k)), as opposed to e.g. {@code Stream.sorted(comparator).limit(k)}, which currently takes O(n
   * log n) time and O(n) space.
   *
   * @throws IllegalArgumentException if {@code k < 0}
   * @since 33.2.0 (available since 22.0 in guava-jre)
   */
  @IgnoreJRERequirement // Users will use this only if they're already using streams.