)
    }
  }

  private fun assertData(hex: String) {
    assertData(hex.decodeHex())
  }

  private fun assertData(expected: ByteString) {
    val actual = data.readByteString(Math.min(expected.size.toLong(), data.size))
    assertThat(actual).isEqualTo(expected)
  }

  companion object {
    private fun binaryData(length: Int): ByteString {

        private int paramWordsWritten = 0;
        private int bytesWritten = 0;
        private int paramWordsRead = 0;
        private int bytesRead = 0;
        private boolean retainPayload = false;
        private byte[] rawPayload = null;

        public TestAndXServerMessageBlock(Configuration config, byte command, ServerMessageBlock andx) {
            super(config, command, andx);
        }

import java.lang.reflect.Field;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import jcifs.smb1.util.Hexdump;

public class SmbComDeleteTest {

    private static final String TEST_FILE_NAME = "testFile.txt";
    private SmbComDelete smbComDelete;

    @BeforeEach
    public void setUp() {
        smbComDelete = new SmbComDelete(TEST_FILE_NAME);
    }

    @Test

import java.util.List;

/**
 * Result of relevance evaluation for search results.
 */
public class RelevanceEvaluationResult {

    private final List<String> relevantDocIds;
    private final List<Integer> relevantIndexes;
    private final boolean hasRelevantResults;

    private RelevanceEvaluationResult(final List<String> relevantDocIds, final List<Integer> relevantIndexes,
            final boolean hasRelevantResults) {

7. Convert the node's keystore to PKCS#12 temporarily so that we can export the private key ( as keytool doesn't allow this)
   `keytool -importkeystore -srckeystore test-node.jks -srcstorepass keypass -destkeystore test-node.p12 -deststoretype PKCS12 -deststorepass keypass`
8. Export the node's private key
   `openssl pkcs12 -in test-node.p12 -passin pass:keypass -nocerts -passout pass:test-node-key-password -out test-node.key`

 * </pre>
 *
 * <p>Note that only top-level classes with either a non-private constructor or a non-private static
 * factory method to construct instances can have their instance methods checked. For example:
 *
 * <pre>
 * public class Address {
 *   private final String city;
 *   private final String state;
 *   private final String zipcode;
 *
 *   public Address(String city, String state, String zipcode) {...}

    @Inject
    private Logger logger;

    @Inject
    private ArtifactFactory artifactFactory;

    @Inject
    private ArtifactResolver artifactResolver;

    @Inject
    private ArtifactRepositoryFactory artifactRepositoryFactory;

    @Inject
    private Map<String, ArtifactRepositoryLayout> layouts;

    @Inject
    private WagonManager wagonManager;

    @Inject

    abstract Cancellable schedule(
        AbstractService service, ScheduledExecutorService executor, Runnable runnable);

    private Scheduler() {}
  }

  /* use AbstractService for state management */
  private final AbstractService delegate = new ServiceDelegate();

  @WeakOuter
  private final class ServiceDelegate extends AbstractService {

public class DefaultWagonManager implements WagonManager {

    private static final String[] CHECKSUM_IDS = {"md5", "sha1"};

    /**
     * have to match the CHECKSUM_IDS
     */
    private static final String[] CHECKSUM_ALGORITHMS = {"MD5", "SHA-1"};

    @Inject
    private Logger logger;

    @Inject
    private PlexusContainer container;

    @Inject
    private UpdateCheckManager updateCheckManager;

    @Inject

  private static final long DUE_DILIGENCE_MILLIS = 100;
  private static final long TIMEOUT_MILLIS = 5000;

  private final L lockLikeObject;

  private final SynchronousQueue<Request> requestQueue = new SynchronousQueue<>();
  private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

  private @Nullable Throwable uncaughtThrowable = null;