/**
   * This counter prevents an ABA issue where a thread may successfully schedule the worker, the
   * worker runs and exhausts the queue, another thread enqueues a task and fails to schedule the
   * worker, and then the first thread's call to delegate.execute() returns. Without this counter,
   * it would observe the QUEUING state and set it to QUEUED, and the worker would never be

        SmbAuthException authEx = new SmbAuthException("denied");

        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(authEx) // first attempt fails with auth
                .thenReturn(handle); // second attempt succeeds

        // dest currently has READONLY attribute set
        int currentAttrs = SmbConstants.ATTR_READONLY | SmbConstants.ATTR_ARCHIVE;

        assertTrue(mockService.unregisterWitness(regId));
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration(regId));

        // 5. Verify heartbeat fails after unregistration
        assertFalse(mockService.processHeartbeat(regId, 4));
    }

    /**
     * Test error conditions and edge cases
     */
    @Test
    void testErrorConditions() {

     *
     * @param <T> the type of the decoded response data
     * @param responseType the class of the expected response type
     * @return decoded data
     * @throws SmbException if decoding fails or the response type is incompatible
     */
    @SuppressWarnings("unchecked")
    public <T extends Decodable> T getOutputData(final Class<T> responseType) throws SmbException {

	return tillOffset
}

// erasureSelfTest performs a self-test to ensure that erasure
// algorithms compute expected erasure codes. If any algorithm
// produces an incorrect value it fails with a hard error.
//
// erasureSelfTest tries to catch any issue in the erasure implementation
// early instead of silently corrupting data.
func erasureSelfTest() {
	// Approx runtime ~1ms

 *   <li>comparing each pair of objects from different equality groups returns false
 *   <li>the hash codes of any two equal objects are equal
 * </ul>
 *
 * <p>When a test fails, the error message labels the objects involved in the failed comparison as
 * follows:
 *
 * <ul>
 *   <li>"{@code [group }<i>i</i>{@code , item }<i>j</i>{@code ]}" refers to the

                    this.handle = this.pipe.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, 0);
                } else {
                    // at least on samba, SmbComOpenAndX fails without the pipe prefix
                    this.handle = this.pipe.openUnshared("\\pipe" + getUncPath(), this.openFlags, this.access, this.sharing,
                            SmbConstants.ATTR_NORMAL, 0);
                }

    // is cancelled.
    future1.cancel(false);

    // Give the second task a chance to (incorrectly) start up while the first task is running.
    // (This is the assertion that fails.)
    assertThat(future2.isDone()).isFalse();

    // Stop the first task. The second task should then run.
    blockingCallable.stop();
    executor.shutdown();

        </field>
        <field>
          <name>checksumPolicy</name>
          <version>1.0.0</version>
          <description>
            What to do when verification of an artifact checksum fails. Valid values are "fail" (default for Maven 4 and
            above), "warn" (default for Maven 3) or "ignore".
          </description>
          <type>String</type>
        </field>
      </fields>
    </class>

  fun cancel()

  fun interface Factory {
    /**
     * Creates a new web socket and immediately returns it. Creating a web socket initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must either close or cancel the returned web socket when it is no longer
     * in use.
     */
    fun newWebSocket(
      request: Request,