time.Sleep(100 * time.Millisecond)
	ps.Lock()
	if len(ps.subs) != 1 {
		t.Fatal("expected 1 subscriber")
	}
	ps.Unlock()
	close(doneCh2)
}

type maskString string

func (m maskString) Mask() uint64 {
	return 1
}

func TestPubSub(t *testing.T) {
	ps := New[Maskable, Maskable](1)
	ch1 := make(chan Maskable, 1)
	doneCh1 := make(chan struct{})

        assertTrue(result > 0);
        assertNotNull(response.getSecurityDescriptor());
    }

    @Test
    @DisplayName("Test toString returns expected format")
    void testToString() {
        String result = response.toString();

        assertNotNull(result);
        assertTrue(result.startsWith("NtTransQuerySecurityResponse["));
        assertTrue(result.endsWith("]"));
    }

    @Test

    private static final int SIGNATURE_LENGTH = 16;
    private final Mac digest;
    private final ReentrantLock signingLock = new ReentrantLock();
    private byte[] signingKey;
    private final String algorithmName;
    private final java.security.Provider provider;
    private volatile boolean closed = false;

    /**
     * Constructs a SMB2 signing digest with the specified session key and dialect
     *

        SmbTree tree = new SmbTree(session, "testShare", "testService");
        tree.tid = 123;
        tree.inDfs = true;
        tree.inDomainDfs = false;
        tree.connectionState = 2;

        String result = tree.toString();
        // Verify the toString contains the expected information
        assertTrue(result.contains("TESTSHARE"));
        assertTrue(result.contains("testService"));

  }

  private fun executeSynchronously(request: Request): RecordedResponse {
    val call = client.newCall(request)
    return try {
      val response = call.execute()
      val bodyString = response.body.string()
      RecordedResponse(request, response, null, bodyString, null)
    } catch (e: IOException) {
      RecordedResponse(request, null, null, null, e)
    }
  }

    this.executorServiceOrNull = executorService
  }

  internal fun enqueue(call: AsyncCall) {
    promoteAndExecute(enqueuedCall = call)
  }

  private fun findExistingCallWithHost(host: String): AsyncCall? {
    for (existingCall in runningAsyncCalls) {
      if (existingCall.host == host) return existingCall
    }
    for (existingCall in readyAsyncCalls) {

      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>

   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font>

			staleDisks[j] = badDisk{nil}
		}

		staleWriters := make([]io.Writer, len(staleDisks))
		for i, disk := range staleDisks {
			if disk == nil {
				continue
			}
			os.Remove(pathJoin(disk.String(), "testbucket", "testobject"))
			staleWriters[i] = newBitrotWriter(disk, "", "testbucket", "testobject", erasure.ShardFileSize(test.size), test.algorithm, erasure.ShardSize())
		}

#       by Bash, Ksh, etc; in particular arrays are avoided.
#
#       The "traditional" practice of packing multiple parameters into a
#       space-separated string is a well documented source of bugs and security
#       problems, so this is (mostly) avoided, by progressively accumulating
#       options in "$@", and eventually passing that to Java.
#

        return MIN_COMPRESSION_SIZE;
    }

    @Override
    public int getMaxCompressionSize() {
        return MAX_COMPRESSION_SIZE;
    }

    @Override
    public String getAlgorithmName(int algorithm) {
        switch (algorithm) {
        case COMPRESSION_NONE:
            return "None";
        case COMPRESSION_LZ77:
            return "LZ77";