*     }
 *     V result = value;
 *     value = null;
 *     notifyAll();
 *     return result;
 *   }
 *
 *   public synchronized void set(V newValue) throws InterruptedException {
 *     while (value != null) {
 *       wait();
 *     }
 *     value = newValue;
 *     notifyAll();
 *   }
 * }
 * }
 *
 * <h3>{@code ReentrantLock}</h3>
 *

    public void test_overwriteValues() {
        dataStoreParams.put("key1", "originalValue");
        assertEquals("originalValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", "newValue");
        assertEquals("newValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", null);
        assertNull(dataStoreParams.get("key1"));
    }

    // Test multiple operations in sequence

        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("value", "newValue");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

   *
   * @param currentValue the current value (of either base or a cell)
   * @param newValue the argument from a user update call
   * @return result of the update function
   */
  abstract long fn(long currentValue, long newValue);

  /**
   * Handles cases of updates involving initialization, resizing, creating new Cells, and/or

        .apply {
          for (i in 0 until url.querySize) {
            val parameterName = url.queryParameterName(i)
            val newValue = if (parameterName in queryParamsNameToRedact) "██" else url.queryParameterValue(i)

            addEncodedQueryParameter(parameterName, newValue)
          }
        }.toString()
    }

    private fun logHeader(
      headers: Headers,
      i: Int,
    ) {

        assertEquals(true, builder.initialSettings.get("key3"));

        // Test overwriting existing setting
        builder.addInitialSettings("key1", "newValue1");
        assertEquals(3, builder.initialSettings.size());
        assertEquals("newValue1", builder.initialSettings.get("key1"));
    }

    @Test
    public void testAddInitialSettingsWithNullValue() {
        // Test adding null value

        ProtwordsItem item = new ProtwordsItem(1, "oldValue");
        item.setNewInput("newValue");

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

        // Write the same item (should update)
        ProtwordsItem result = updater.write(item);

        assertNotNull(result);
        assertEquals("newValue", result.getInput());
        assertEquals(1, result.getId());

  @CollectionSize.Require(absent = ZERO)
  public void testComputeIfAbsent_nullTreatedAsAbsent() {
    initMapWithNullValue();
    assertEquals(
        "computeIfAbsent(presentAssignedToNull, function) should return newValue",
        getValueForNullKey(),
        getMap()
            .computeIfAbsent(
                getKeyForNullValue(),
                k -> {
                  assertEquals(getKeyForNullValue(), k);

   *     flooding attack
   */
  @CanIgnoreReturnValue
  static <K, V> @Nullable ImmutableMapEntry<K, V> checkNoConflictInKeyBucket(
      Object key,
      Object newValue,
      @Nullable ImmutableMapEntry<K, V> keyBucketHead,
      boolean throwIfDuplicateKeys)
      throws BucketOverflowException {
    int bucketSize = 0;

  }

  @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
  public @Nullable V replace(K key, V value) {