size -= oldCount;
    } else {
      backingMap.setValue(entryIndex, newCount);
      size += newCount - oldCount;
    }
    return true;
  }

  @Override
  public final void clear() {
    backingMap.clear();
    size = 0;
  }

  /**
   * Skeleton of per-entry iterators. We could push this down and win a few bytes, but it's complex
   * enough it's not especially worth it.
   */

        docList.addContentSize(1000);
        docList.addProcessingTime(999);
        assertEquals(1000, docList.getContentSize());
        assertEquals(999, docList.getProcessingTime());

        docList.clear();
        assertEquals(0, docList.getContentSize());
        assertEquals(0, docList.getProcessingTime());
    }

    @Test
    public void test_addContentSize_multiple() {
        DocList docList = new DocList();

        return key;
    }

    /**
     * Clear all stored keys
     */
    public void clearAllKeys() {
        checkNotClosed();

        log.info("Clearing all stored keys");

        // Wipe all raw keys
        for (Map.Entry<String, byte[]> entry : rawKeys.entrySet()) {
            Arrays.fill(entry.getValue(), (byte) 0);
        }
        rawKeys.clear();

        // Destroy all secret keys

    Inverse(HashBiMap<K, V> obverse) {
      this.obverse = obverse;
    }

    @Override
    public int size() {
      return obverse.size;
    }

    @Override
    public void clear() {
      obverse.clear();
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      Object obverseValue = key;
      return obverse.containsValue(obverseValue);
    }

    @Override

        List<SmbTransportImpl> toClose = new ArrayList<>(this.connections);
        toClose.addAll(this.nonPooledConnections);

        // Clear the collections (thread-safe operations)
        this.connections.clear();
        this.nonPooledConnections.clear();
        this.activeConnections.set(0);

        // Close all connections outside of synchronization
        for (final SmbTransportImpl conn : toClose) {

items = {}


@asynccontextmanager
async def lifespan(app: FastAPI):
    items["foo"] = {"name": "Fighters"}
    items["bar"] = {"name": "Tenders"}
    yield
    # clean up items
    items.clear()


app = FastAPI(lifespan=lifespan)


@app.get("/items/{item_id}")
async def read_items(item_id: str):
    return items[item_id]


def test_read_items():

    }

    @Override
    public boolean contains(@Nullable Object o) {
      return AbstractMultimap.this.containsValue(o);
    }

    @Override
    public void clear() {
      AbstractMultimap.this.clear();
    }
  }

  Iterator<V> valueIterator() {
    return Maps.valueIterator(entries().iterator());
  }

  @LazyInit private transient @Nullable Map<K, Collection<V>> asMap;

        // Invalid integer should use default
        props.clear();
        props.setProperty("jcifs.smb.client.maxChannels", "invalid");
        config = new PropertyConfiguration(props);
        assertEquals(4, config.getMaxChannels());

        // Invalid channel binding policy should default to preferred
        props.clear();
        props.setProperty("jcifs.smb.client.channelBindingPolicy", "invalid");

            fail("Failed to reset SingletonContext instance: " + e.getMessage());
        }
        // Clear system properties that might affect the test
        System.clearProperty("jcifs.properties");
        System.clearProperty("java.protocol.handler.pkgs");
        // Clear jcifs-specific properties to prevent test interference
        System.clearProperty("jcifs.smb.client.nativeOs");

    }

    @Override
    public Iterator<K> iterator() {
      return keySetIterator();
    }

    @Override
    public void clear() {
      CompactHashMap.this.clear();
    }
  }

  Iterator<K> keySetIterator() {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.keySet().iterator();
    }