}

    @Override
    public Integer set(int index, Integer element) {
      checkElementIndex(index, size());
      int oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Integer> subList(int fromIndex, int toIndex) {
      int size = size();

  }

  @CanIgnoreReturnValue
  @Override
  public boolean replace(K key, @Nullable V oldValue, V newValue) {
    checkNotNull(key);
    checkNotNull(newValue);
    if (oldValue == null) {
      return false;
    }
    int hash = hash(key);
    return segmentFor(hash).replace(key, hash, oldValue, newValue);
  }

  @CanIgnoreReturnValue
  @Override

    }

    @Override
    public Long set(int index, Long element) {
      checkElementIndex(index, size());
      long oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Long> subList(int fromIndex, int toIndex) {
      int size = size();

    }

    @Override
    public Character set(int index, Character element) {
      checkElementIndex(index, size());
      char oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Character> subList(int fromIndex, int toIndex) {
      int size = size();

    }

    @Override
    public Float set(int index, Float element) {
      checkElementIndex(index, size());
      float oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Float> subList(int fromIndex, int toIndex) {
      int size = size();

    }

    @Override
    public Double set(int index, Double element) {
      checkElementIndex(index, size());
      double oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Double> subList(int fromIndex, int toIndex) {
      int size = size();

    }

    public void test_ProtwordsUpdater_write_updateItem() {
        protwordsFile.reload(null);

        // Create an item for update
        ProtwordsItem item = new ProtwordsItem(1, "oldValue");
        item.setNewInput("newValue");

        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(item);

        // Write the same item (should update)

        assertEquals("value1", paramMap.get("key1"));
        assertEquals("value2", paramMap.get("key2"));

        // Test overwriting existing keys
        paramMap = new HashMap<>();
        paramMap.put("key1", "oldValue");
        configParam = "key1=newValue";
        ParameterUtil.loadConfigParams(paramMap, configParam);
        assertEquals(1, paramMap.size());
        assertEquals("newValue", paramMap.get("key1"));
    }

   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean replace(K key, V oldValue, V newValue) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the map unmodified.
   *
   * @throws UnsupportedOperationException always

  public void testReplaceValuesWithEmpty() {
    int size = multimap().size();
    List<V> oldValues = new ArrayList<>(multimap().get(k0()));
    List<V> values = emptyList();
    assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values)));
    assertGet(k0());
    assertEquals(size - oldValues.size(), multimap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})