@Override
        public ResponseData execute(final RequestData request) {
            final long now = SystemUtil.currentTimeMillis();
            if (now - previousTime < interval) {
                throw new IllegalStateException();
            }
            previousTime = now;

            count++;
            if (count <= exceptionCount) {
                throw new CrawlerSystemException("exception " + count);
            }

  }

  public void testBase64CannotUpperCase() {
    assertThrows(IllegalStateException.class, () -> base64().upperCase());
  }

  public void testBase64CannotLowerCase() {
    assertThrows(IllegalStateException.class, () -> base64().lowerCase());
  }

  public void testBase64CannotIgnoreCase() {
    assertThrows(IllegalStateException.class, () -> base64().ignoreCase());
  }

   * {@code int} value in little-endian order.
   *
   * @throws IllegalStateException if {@code bits() < 32}
   */
  public abstract int asInt();

  /**
   * Returns the first eight bytes of {@linkplain #asBytes() this hashcode's bytes}, converted to a
   * {@code long} value in little-endian order.
   *
   * @throws IllegalStateException if {@code bits() < 64}
   */
  public abstract long asLong();

  /**

    Lock lockA = factory.newReentrantLock(OtherOrder.FIRST);
    Lock lockB = factory.newReentrantReadWriteLock(OtherOrder.FIRST).readLock();

    lockA.lock();
    assertThrows(IllegalStateException.class, () -> lockB.lock());

    lockA.unlock();
    lockB.lock();
  }

  public void testReadLock_deadlock() {
    readLockA.lock(); // Establish an ordering from readLockA -> lockB.

    Lock lockA = factory.newReentrantLock(OtherOrder.FIRST);
    Lock lockB = factory.newReentrantReadWriteLock(OtherOrder.FIRST).readLock();

    lockA.lock();
    assertThrows(IllegalStateException.class, () -> lockB.lock());

    lockA.unlock();
    lockB.lock();
  }

  public void testReadLock_deadlock() {
    readLockA.lock(); // Establish an ordering from readLockA -> lockB.

            pos += writeSecurityBufferContent(type1, pos, wsOffOff, workstation);
            return type1;
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    public String toString () {
        String suppliedDomainString = getSuppliedDomain();

    sizesToTest.retainAll(asList(CollectionSize.ZERO, CollectionSize.ONE, CollectionSize.SEVERAL));

    logger.fine("   Sizes: " + formatFeatureSet(sizesToTest));

    if (sizesToTest.isEmpty()) {
      throw new IllegalStateException(
          name
              + ": no CollectionSizes specified (check the argument to "
              + "FeatureSpecificTestSuiteBuilder.withFeatures().)");
    }

    TestSuite suite = new TestSuite(name);

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *
   * @throws IllegalStateException if there has been a call to {@link #peek()} since the most recent
   *     call to {@link #next()} and this implementation does not support this sequence of calls
   *     (optional)
   */
  @Override
  void remove();

   *
   * <p>If {@code node} is removed from the graph after this method is called, the {@code Set}
   * {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>
   *   <li>{@code view.equals(view)} evaluates to {@code true} (but any other {@code equals()}

    assertThat(p1.string()).isEqualTo("abcd")
    assertThat(p2.string()).isEqualTo("ab")
  }

  @Test fun negativeStatusCodeThrowsIllegalStateException() {
    assertFailsWith<IllegalStateException> {
      newResponse(responseBody("set status code -1"), -1)
    }
  }

  @Test fun zeroStatusCodeIsValid() {
    val response = newResponse(responseBody("set status code 0"), 0)