* @param <N> Node parameter type
 * @param <V> Value parameter type
 */
@ElementTypesAreNonnullByDefault
final class UndirectedGraphConnections<N, V> implements GraphConnections<N, V> {
  private final Map<N, V> adjacentNodeValues;

  private UndirectedGraphConnections(Map<N, V> adjacentNodeValues) {
    this.adjacentNodeValues = checkNotNull(adjacentNodeValues);
  }

import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

public class ApiAdminUserAction extends FessApiAdminAction {

    private static final Logger logger = LogManager.getLogger(ApiAdminUserAction.class);

    @Resource
    private UserService userService;

    // GET /api/admin/user/settings
    // POST /api/admin/user/settings
    @Execute

import junit.framework.TestCase;

/**
 * Unit test for {@link Stopwatch}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class StopwatchTest extends TestCase {

  private final FakeTicker ticker = new FakeTicker();
  private final Stopwatch stopwatch = new Stopwatch(ticker);

  public void testCreateStarted() {
    Stopwatch startedStopwatch = Stopwatch.createStarted();
    assertTrue(startedStopwatch.isRunning());

 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
public class ForwardingListTest extends TestCase {
  static final class StandardImplForwardingList<T> extends ForwardingList<T> {
    private final List<T> backingList;

    StandardImplForwardingList(List<T> backingList) {
      this.backingList = backingList;
    }

    @Override
    protected List<T> delegate() {
      return backingList;
    }

 *
 * @author Louis Wasserman
 */
public class ForwardingSortedMultisetTest extends TestCase {
  static class StandardImplForwardingSortedMultiset<E> extends ForwardingSortedMultiset<E> {
    private final SortedMultiset<E> backingMultiset;

    StandardImplForwardingSortedMultiset(SortedMultiset<E> backingMultiset) {
      this.backingMultiset = backingMultiset;
    }

    @Override

 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
public class ForwardingListTest extends TestCase {
  static final class StandardImplForwardingList<T> extends ForwardingList<T> {
    private final List<T> backingList;

    StandardImplForwardingList(List<T> backingList) {
      this.backingList = backingList;
    }

    @Override
    protected List<T> delegate() {
      return backingList;
    }

    private static final String META_NAME_ROBOTS_CONTENT = "//META[@name=\"robots\" or @name=\"ROBOTS\"]/@content";

    private static final String ROBOTS_TAG_NONE = "none";

    private static final String ROBOTS_TAG_NOINDEX = "noindex";

    private static final String ROBOTS_TAG_NOFOLLOW = "nofollow";

    private static final int UTF8_BOM_SIZE = 3;

    public boolean prunedContent = true;

      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,
        "the total number of elements (%s) in the arrays must fit in an int",
        result);
    return (int) result;
  }

  private static final class FloatConverter extends Converter<String, Float>
      implements Serializable {

  private final LockFreeBitArray bits;

  /** Number of hashes per element */
  private final int numHashFunctions;

  /** The funnel to translate Ts to bytes */
  private final Funnel<? super T> funnel;

  /** The strategy we employ to map an element T to {@code numHashFunctions} bit indexes. */
  private final Strategy strategy;

  /** Creates a BloomFilter. */

      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,
        "the total number of elements (%s) in the arrays must fit in an int",
        result);
    return (int) result;
  }

  private static final class FloatConverter extends Converter<String, Float>
      implements Serializable {