go func() {
   for {
    // Reconnect if the connection is lost.
    if stanConnection == nil || stanConnection.NatsConn() == nil ||  !stanConnection.NatsConn().IsConnected() {
     stanConnection, _ = stan.Connect("test-cluster", "test-client", stan.NatsURL("nats://yourusername:yoursecret@0.0.0.0:4222"), stan.SetConnectionLostHandler(func(c stan.Conn, _ error) {
      if c.NatsConn() != nil {

   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can
   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

  @SuppressWarnings("unchecked") // not really safe, but that's the point

		t.Log("WARNING: TestEncodeDecodeBatchJobPrefix Msgsize() is inaccurate")
	}

	vn := BatchJobPrefix{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBatchJobPrefix(b *testing.B) {
	v := BatchJobPrefix{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

		t.Log("WARNING: TestEncodeDecodelocalLockMap Msgsize() is inaccurate")
	}

	vn := localLockMap{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodelocalLockMap(b *testing.B) {
	v := localLockMap{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

func (r *Reader) ETag() ETag {
	sum := r.md5.Sum(nil)
	return ETag(sum)
}

// VerifyError is an error signaling that a
// computed ETag does not match an expected
// ETag.
type VerifyError struct {
	Expected ETag
	Computed ETag
}

func (v VerifyError) Error() string {
	return fmt.Sprintf("etag: expected ETag %q does not match computed ETag %q", v.Expected, v.Computed)
}

    /**
     * Human-readable error messages corresponding to DOS error codes.
     * Provides descriptive text for each error condition.
     */
    /*
     * These aren't really used by jCIFS--
     * the map above is used to immediately
     * map to NTSTATUS codes.
     */
    /**
     * Human-readable error messages corresponding to DOS error codes.

        verify(transport).isSigningEnforced();
    }

    // Error propagation: signing checks may throw SmbException
    @Test
    @DisplayName("signing checks propagate SmbException")
    void signingChecks_throw() throws Exception {
        doThrow(new SmbException("opt error")).when(transport).isSigningOptional();
        doThrow(new SmbException("enf error")).when(transport).isSigningEnforced();

    equalsTester = new EqualsTester();
    equalObject1 = new ValidTestObject(1, 2);
    equalObject2 = new ValidTestObject(1, 2);
    notEqualObject1 = new ValidTestObject(0, 2);
  }

  /** Test null reference yields error */
  public void testAddNullReference() {
    assertThrows(NullPointerException.class, () -> equalsTester.addEqualityGroup((Object) null));
  }

  /** Test equalObjects after adding multiple instances at once with a null */

    /**
     * Sets up the test environment before each test.
     * Initializes a mock {@link SmbPipeResource} and a mock implementation of {@link SmbPipeHandle}.
     * @throws CIFSException if an error occurs during setup.
     */
    @BeforeEach
    public void setUp() throws CIFSException {
        mockPipeResource = mock(SmbPipeResource.class);
        mockSmbPipeHandleInternal = mock(SmbPipeHandleInternal.class);

        String server = "testServer";
        int access = 123;
        int errorRetval = 12345; // Simulate an error code

        // Setup for successful constructor
        doNothing().when(mockHandle).sendrecv(any(MsrpcSamrConnect4.class));

        // Setup for close to return an error
        ArgumentCaptor<MsrpcSamrCloseHandle> closeCaptor = ArgumentCaptor.forClass(MsrpcSamrCloseHandle.class);