* to avoid code-size bloat.
 *
 * @author Hayward Chan
 */
final class ImmutableEnumSet<E> extends ForwardingImmutableSet<E> {
  static <E> ImmutableSet<E> asImmutable(Set<E> delegate) {
    switch (delegate.size()) {
      case 0:
        return ImmutableSet.of();
      case 1:
        return ImmutableSet.of(Iterables.getOnlyElement(delegate));
      default:

  }

  static <N, E> UndirectedNetworkConnections<N, E> of() {
    return new UndirectedNetworkConnections<>(HashBiMap.<E, N>create(EXPECTED_DEGREE));
  }

  static <N, E> UndirectedNetworkConnections<N, E> ofImmutable(Map<E, N> incidentEdges) {
    return new UndirectedNetworkConnections<>(ImmutableBiMap.copyOf(incidentEdges));
  }

  @Override
  public Set<N> adjacentNodes() {

- The `TerminationGracePeriodSeconds` on pod specs and container probes should not be negative. Negative values of `TerminationGracePeriodSeconds` will be treated as the value `1s` on the delete path. Immutable field validation will be relaxed in order to update negative values. In a future release, negative values will not be permitted. ([#98866](https://github.com/kubernetes/kubernetes/pull/98866), [@wzshiming](https://github.com/wzshiming))

            new LinkedHashMap<N, V>(INNER_CAPACITY, INNER_LOAD_FACTOR));
      default:
        throw new AssertionError(incidentEdgeOrder.type());
    }
  }

  static <N, V> UndirectedGraphConnections<N, V> ofImmutable(Map<N, V> adjacentNodeValues) {
    return new UndirectedGraphConnections<>(ImmutableMap.copyOf(adjacentNodeValues));
  }

  @Override
  public Set<N> adjacentNodes() {

//
public interface RepositoryCache {

    /**
     * Puts the specified data into the cache. <strong>Warning:</strong> The cache will directly save the provided
     * reference. If the cached data is mutable, i.e. could be modified after being put into the cache, the caller is
     * responsible for creating a copy of the original data and store the copy in the cache.
     *

    return new UndirectedMultiNetworkConnections<>(
        new HashMap<E, N>(INNER_CAPACITY, INNER_LOAD_FACTOR));
  }

  static <N, E> UndirectedMultiNetworkConnections<N, E> ofImmutable(Map<E, N> incidentEdges) {
    return new UndirectedMultiNetworkConnections<>(ImmutableMap.copyOf(incidentEdges));
  }

  @LazyInit private transient @Nullable Reference<Multiset<N>> adjacentNodesReference;

  @Override

@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization
final class ImmutableEnumMap<K extends Enum<K>, V> extends IteratorBasedImmutableMap<K, V> {
  static <K extends Enum<K>, V> ImmutableMap<K, V> asImmutable(EnumMap<K, V> map) {
    switch (map.size()) {
      case 0:
        return ImmutableMap.of();
      case 1:
        Entry<K, V> entry = getOnlyElement(map.entrySet());

import org.apache.maven.api.annotations.Nonnull;

import static java.util.Objects.requireNonNull;

/**
 * A thin wrapper for a {@link Path} that serves as "current working directory" value. Hence, this class
 * is mutable (as CWD may be changed), but allows transition only to existing directories.
 */
public final class CWD implements Supplier<Path> {
    /**
     * Creates instance out of {@link Path}.
     */

 */
@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization
final class ImmutableEnumSet<E extends Enum<E>> extends ImmutableSet<E> {
  static <E extends Enum<E>> ImmutableSet<E> asImmutable(EnumSet<E> set) {
    switch (set.size()) {
      case 0:
        return ImmutableSet.of();
      case 1:
        return ImmutableSet.of(getOnlyElement(set));
      default:

    @Test
    @DisplayName("ltime field is mutable")
    void testLtimeField() {
        TestLocking t = new TestLocking();

        // Initial value
        assertEquals(0L, t.ltime, "ltime should start at 0");

        // Set new value
        long currentTime = System.currentTimeMillis();
        t.ltime = currentTime;
        assertEquals(currentTime, t.ltime, "ltime should be mutable");
    }

    @Test