public int getPriority() {
        return 1;
    }

    @Override
    public void setName(String name) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void setPriority(int priority) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getDescription() {
        return "Reports incorrect usages of integration test fixtures";
    }

    super(true, true, false, false, false);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return ArrayTable.create(

    super(true, true, false, false, false);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return ArrayTable.create(

      getMap().remove(k0(), v0());
      fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedAbsent() {
    try {
      assertFalse(getMap().remove(k0(), v3()));
    } catch (UnsupportedOperationException tolerated) {

    return backingIterator().previousIndex();
  }

  @Override
  public void set(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void add(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

              });
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testReplaceAll_unsupportedNoOpFunction() {
    try {
      getMap().replaceAll((K k, V v) -> v);
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  public void testAddUnsupported() {
    try {
      getMultiset().add(e0());
      fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException expected) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddMeansAddOne() {
    int originalCount = getMultiset().count(e0());

      fail("putAll(somePresent) should throw");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutAll_unsupportedAllPresent() {
    try {
      putAll(MinimalCollection.of(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_unsupportedPresent() {
    try {
      getMap().replace(k0(), v0(), v3());
      fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

  internal val delegate = QueueDispatcher()

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  override fun peek(): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueueResponse(response.wrap())
  }