iterator.next();
      iterator.remove();
      assertEquals(initialSize - 1, map.size());
      // (We can't assert that the values collection no longer contains the
      // removed value, because the underlying map can have multiple mappings
      // to the same value.)
      assertInvariants(map);
      assertThrows(IllegalStateException.class, iterator::remove);
    } else {
      iterator.next();

 * TLS_RSA_WITH_AES_128_CBC_SHA[²][http2_naughty]
 * TLS_RSA_WITH_AES_256_CBC_SHA[²][http2_naughty]
 * TLS_RSA_WITH_3DES_EDE_CBC_SHA[²][http2_naughty]
 * **REMOVED:** ~~TLS_DHE_RSA_WITH_AES_128_CBC_SHA~~
 * **REMOVED:** ~~TLS_DHE_RSA_WITH_AES_128_GCM_SHA256~~
 * **REMOVED:** ~~TLS_DHE_RSA_WITH_AES_256_CBC_SHA~~

[OkHttp 3.0][OkHttp30]
----------------------

_2016-01-13_

##### MODERN_TLS / COMPATIBLE_TLS cipher suites

            }
            return Byte.valueOf((byte) 0);
        }
        return o;
    }

    /**
     * Removes delimiters.
     *
     * @param value
     *            String value
     * @param locale
     *            Locale
     * @return String result with delimiters removed
     */
    public static String removeDelimeter(String value, final Locale locale) {

        recurse(level + 1);
      }
    }
  }

  private void compareResultsForThisListOfStimuli() {
    int removes = frequency(asList(stimuli), remove);
    if ((!features.contains(IteratorFeature.SUPPORTS_REMOVE) && removes > 1)
        || (stimuli.length >= 5 && removes > 2)) {
      // removes are the most expensive thing to test, since they often throw exceptions with stack
      // traces, so we test them a bit less aggressively

      return delegate.poll();
    }

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override
    public boolean remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove(object);
    }

    @Override
    public @Nullable E peek() {

    }

    @Test
    @DisplayName("EmptyIterator should handle remove operations multiple times")
    void testMultipleRemoveOperations() {
        // When & Then
        assertDoesNotThrow(() -> {
            emptyIterator.remove();
            emptyIterator.remove();
            emptyIterator.remove();
        }, "Multiple remove operations should not cause issues");

    assertEquals(Integer.valueOf(50), asMap.get(10));
    assertEquals(Integer.valueOf(79), cache.getIfPresent(2));
    assertEquals(Integer.valueOf(79), asMap.get(2));

    asMap.remove(10, 100);
    asMap.remove(2, 79);

    assertEquals(Integer.valueOf(50), cache.getIfPresent(10));
    assertEquals(Integer.valueOf(50), asMap.get(10));
    assertEquals(null, cache.getIfPresent(2));

      K key = keys[entry];
      removeEntryValueHashKnown(entry, valueHash);
      return key;
    }
  }

  /** Removes the entry at the specified index with no additional data. */
  void removeEntry(int entry) {
    removeEntryKeyHashKnown(entry, Hashing.smearedHash(keys[entry]));
  }

  /** Removes the entry at the specified index, given the hash of its key and value. */

      if (currentSubscribers == null || !currentSubscribers.removeAll(listenerMethodsForType)) {
        // if removeAll returns true, all we really know is that at least one subscriber was
        // removed... however, barring something very strange we can assume that if at least one
        // subscriber was removed, all subscribers on listener for that event type were... after

        }
    }

    /**
     * Removes a scheduled job completely from the job manager.
     *
     * @param scheduledJob the scheduled job to remove
     * @throws ScheduledJobException if the job cannot be removed
     */
    public void remove(final ScheduledJob scheduledJob) {
        try {