*
 */
public interface DataService<RESULT extends AccessResult<?>> {

    void store(RESULT accessResult);

    void update(RESULT accessResult);

    void update(List<RESULT> accessResult);

    int getCount(String sessionId);

    void delete(String sessionId);

    void deleteAll();

    RESULT getAccessResult(String sessionId, String url);

    List<RESULT> getAccessResultList(String url, boolean hasData);

    }

    public void expectCall() {
      assertFalse("expectCall is already true", expectCall);
      expectCall = true;
    }

    public boolean wasCalled() {
      return calledCountDown.getCount() == 0;
    }

    public void waitForCall() throws InterruptedException {
      assertTrue("expectCall is false", expectCall);
      calledCountDown.await();
    }
  }

        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public MemoryUsage getUsage() {
        return usage;
    }

    public long getCount() {
        return count;
    }

        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_WAIT_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0;
        maxSetupCount = (byte)0x00;
        setupCount = 2;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        dst[dstIndex++] = subCommand;
        dst[dstIndex++] = (byte)0x00;
        dst[dstIndex++] = (byte)0x00; // no FID

	_POLLIN  = 0x1
	_POLLOUT = 0x4
	_POLLHUP = 0x10
	_POLLERR = 0x8

	_PORT_SOURCE_FD    = 0x4
	_PORT_SOURCE_ALERT = 0x5
	_PORT_ALERT_UPDATE = 0x2
)

type semt struct {
	sem_count uint32
	sem_type  uint16
	sem_magic uint16
	sem_pad1  [3]uint64
	sem_pad2  [2]uint64
}

type sigset struct {
	__sigbits [4]uint32
}

type stackt struct {
	ss_sp     *byte

            dstIndex += 4;
            dst[ dstIndex++ ] = (byte) 0x00; // Reserved1
        }
        else {
            dst[ dstIndex++ ] = (byte) this.setupCount;
            SMBUtil.writeInt2(this.function, dst, dstIndex);
            dstIndex += 2;
            dstIndex += writeSetupWireFormat(dst, dstIndex);
        }

        return dstIndex - start;
    }

          protected void finalize() {
            latch.countDown();
          }
        };
    x = null; // Hint to the JIT that x is unreachable
    GcFinalization.await(latch);
    assertEquals(0, latch.getCount());
  }

  public void testAwaitDone_Future() {
    final SettableFuture<@Nullable Void> future = SettableFuture.create();
    Object x =
        new Object() {
          @Override

        this.name = pipeName;
        this.timeout = 0xFFFFFFFF;
        this.maxParameterCount = 0;
        this.maxDataCount = 0;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
    }


    @Override
    protected int writeSetupWireFormat ( byte[] dst, int dstIndex ) {
        dst[ dstIndex++ ] = this.getSubCommand();
        dst[ dstIndex++ ] = (byte) 0x00;

        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_PEEK_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 6;
        maxDataCount = 1;
        maxSetupCount = (byte)0x00;
        setupCount = 2;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        dst[dstIndex++] = subCommand;
        dst[dstIndex++] = (byte)0x00;
        // this says "Transaction priority" in netmon

      @SuppressWarnings("unchecked") // safe because we only read from it
      Entry<E> entry = (Entry<E>) entryWithWildcard;
      E element = checkNotNull(entry.getElement());
      int count = entry.getCount();
      int hash = element.hashCode();
      int bucket = Hashing.smear(hash) & mask;
      ImmutableEntry<E> bucketHead = hashTable[bucket];
      ImmutableEntry<E> newEntry;
      if (bucketHead == null) {