if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }
            newClientMap.put(entry.getKey(), entry.getValue());
            current++;
        }
        if (!added) {
            newClientMap.put(Pattern.compile(regex), client);
        }
        clientMap = newClientMap;
    }

    /**

     * Adds an entry to the built multimap.
     *
     * @since 11.0
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
      return put(entry.getKey(), entry.getValue());
    }

    /**
     * Adds entries to the built multimap.
     *
     * @since 19.0
     */
    @CanIgnoreReturnValue

                case 0:
                    return emptyMap();
                case 1:
                    Map.Entry<K, V> entry = map.entrySet().iterator().next();
                    return singletonMap(entry.getKey(), entry.getValue());
                default:
                    return new MapN<>(map);
            }
        }
    }

    @SuppressWarnings("unchecked")
    static <K, V> Map<K, V> emptyMap() {

    assertThat(entry.getValue()).isEqualTo("World");
    assertTrue(iter.hasNext());

    entry = iter.next();
    assertThat(entry.getKey()).isEqualTo("first");
    assertThat(entry.getValue()).isEqualTo("second");
    assertTrue(iter.hasNext());

    entry = iter.next();
    assertThat(entry.getKey()).isEqualTo("polygene");
    assertThat(entry.getValue()).isEqualTo("lubricants");

      assertEquals(2 * i, (int) inverse.get(2 * i - 1));
    }
    Set<Entry<Integer, Integer>> entries = bimap.entrySet();
    for (Entry<Integer, Integer> entry : entries) {
      entry.setValue(entry.getValue() + 2 * N);
    }
    for (int i = 0; i < N; i++) {
      assertEquals(2 * N + 2 * i - 1, (int) bimap.get(2 * i));
    }
  }

  public void testBiMapEntrySetIteratorRemove() {

                : location.getLocations().entrySet().stream()
                        .collect(Collectors.toMap(
                                e -> e.getKey(),
                                e -> e.getValue() == location ? this : new InputLocation(e.getValue())));
        this.importedFrom = location.getImportedFrom() != null ? new InputLocation(location.getImportedFrom()) : null;
    }

    public InputLocation(int lineNumber, int columnNumber) {

            ArgumentCaptor<Smb2ReadRequest> cap = ArgumentCaptor.forClass(Smb2ReadRequest.class);
            verify(mockTree).send(cap.capture(), any(RequestParam.class));
            Smb2ReadRequest req = cap.getValue();

            // Reflectively inspect the private 'offset' field to assert it used the advanced fp
            Field offField = Smb2ReadRequest.class.getDeclaredField("offset");
            offField.setAccessible(true);

        ArgumentCaptor<CommonServerMessageBlockRequest> reqCap = ArgumentCaptor.forClass(CommonServerMessageBlockRequest.class);
        verify(tree).send(reqCap.capture(), any(), any(), any());
        assertTrue(reqCap.getValue() instanceof Smb2ChangeNotifyRequest, "SMB2 request must be used");
        verify(tree, times(1)).close(); // try-with-resources must close
        verify(handle, never()).markClosed();

  static <K, V> ImmutableMap<K, V> asImmutable(Map<K, V> map) {
    for (Entry<K, V> entry : checkNotNull(map).entrySet()) {
      checkNotNull(entry.getKey());
      checkNotNull(entry.getValue());
    }
    return new ImmutableEnumMap<K, V>(map);
  }

  private ImmutableEnumMap(Map<? extends K, ? extends V> delegate) {
    super(delegate);
  }

                                    || Constants.MAPPING_TYPE_PDF_DATE.equalsIgnoreCase(mapping.getValue2())) {
                                final String dateFormat;
                                if (StringUtil.isNotBlank(mapping.getValue3())) {
                                    dateFormat = mapping.getValue3();
                                } else if (Constants.MAPPING_TYPE_PDF_DATE.equalsIgnoreCase(mapping.getValue2())) {