assertEquals(0L, map.get(key));
    assertFalse(map.containsKey(key));

    assertEquals(-1L, map.decrementAndGet(key));
    assertEquals(-1L, map.get(key));

    assertEquals(0L, map.incrementAndGet(key));
    assertEquals(0L, map.get(key));
    assertTrue(map.containsKey(key));

    assertEquals(-1L, map.decrementAndGet(key));
    assertEquals(-1L, map.get(key));
  }

  public void testGetAndDecrement() {

     */
    static public byte[] getBuffer() {
        // Try to get from cache first - O(1) operation
        byte[] buf = bufferQueue.poll();
        if (buf != null) {
            queueSize.decrementAndGet();
            return buf;
        }

        // Validate buffer size to prevent overflow
        int bufferSize = SmbComTransaction.TRANSACTION_BUF_SIZE;
        if (bufferSize < 0 || bufferSize > MAX_BUFFER_SIZE) {

        connectionsActive.incrementAndGet();
    }

    /**
     * Record RDMA connection closure
     */
    public void recordConnectionClosed() {
        connectionsActive.decrementAndGet();
    }

    /**
     * Record memory region allocation
     */
    public void recordMemoryRegionAllocated() {
        memoryRegionsAllocated.incrementAndGet();

            }
            this.connections.remove(trans);
            this.nonPooledConnections.remove(trans);
            activeConnections.decrementAndGet();
            connectionsRemoved.incrementAndGet();
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTransportPool#close()
     */
    @Override

        return sendCredits.get() > 0 && state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Consume a send credit
     */
    public void consumeSendCredit() {
        sendCredits.decrementAndGet();
    }

    /**
     * Grant a send credit
     */
    public void grantSendCredit() {
        sendCredits.incrementAndGet();
    }

    /**
     * Grant a receive credit
     */

     * @throws SmbException
     *
     * @see jcifs.SmbFileHandle#release()
     */
    @Override
    public synchronized void release() throws CIFSException {
        final long usage = this.usageCount.decrementAndGet();
        if (usage == 0) {
            closeInternal(0L, false);
        } else if (log.isTraceEnabled()) {
            log.trace(String.format("Release %s (%d)", this, usage));
        }
    }

        if (finishedCall != null) {
          check(runningSyncCalls.remove(finishedCall)) { "Call wasn't in-flight!" }
        }

        if (finishedAsyncCall != null) {
          finishedAsyncCall.callsPerHost.decrementAndGet()
          check(runningAsyncCalls.remove(finishedAsyncCall)) { "Call wasn't in-flight!" }
        }

        if (enqueuedCall != null) {
          readyAsyncCalls.add(enqueuedCall)

    }

    /**
     * Decrements the access count and returns the new value.
     * @return The decremented access count.
     */
    public long decrementAndGetAccessCount() {
        return accessCount.decrementAndGet();
    }

    /**
     * Returns the crawler status.
     * @return The CrawlerStatus.
     */
    public CrawlerStatus getStatus() {
        return status;
    }

    /**

      seenExceptionsUpdater.compareAndSet(state, expect, update);
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      return remainingCountUpdater.decrementAndGet(state);
    }

    @Override
    String atomicHelperTypeForTest() {
      return "SafeAtomicHelper";
    }
  }

  private static final class SynchronizedAtomicHelper extends AtomicHelper {

            this.treeConnection.acquire();
        }
        return this;
    }

    @Override
    public void release() {
        final long us = this.usageCount.decrementAndGet();
        if (us == 0) {
            this.treeConnection.release();
        } else if (us < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }
    }