WebApiException exception2 = new WebApiException(401, "Unauthorized");
        WebApiException exception3 = new WebApiException(500, "Internal Error");

        assertEquals(400, exception1.getStatusCode());
        assertEquals(401, exception2.getStatusCode());
        assertEquals(500, exception3.getStatusCode());

        assertTrue(exception1.getStatusCode() != exception2.getStatusCode());

        info.alloc = 1000;
        info.free = 500;
        info.sectPerAlloc = 100;
        info.bytesPerSect = 512;

        String infoString = info.toString();
        assertTrue(infoString.contains("alloc=1000"), "toString should contain alloc");
        assertTrue(infoString.contains("free=500"), "toString should contain free");

        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)

        SMBUtil.writeInt2(500, buffer, bufferIndex);
        SMBUtil.writeInt2(0, buffer, bufferIndex + 2);
        SMBUtil.writeInt2(TransPeekNamedPipeResponse.STATUS_LISTENING, buffer, bufferIndex + 4);

        // Act
        int result = response.readParametersWireFormat(buffer, bufferIndex, 6);

        // Assert
        assertEquals(6, result);
        assertEquals(500, response.getAvailable());

        sidArray.sids[0].sid.identifier_authority = new byte[] { 0, 0, 0, 0, 0, 5 };
        sidArray.sids[0].sid.sub_authority_count = 1;
        sidArray.sids[0].sid.sub_authority = new int[] { 500 };

        sidArray.sids[1] = new lsarpc.LsarSidPtr();
        sidArray.sids[1].sid = new rpc.sid_t();
        sidArray.sids[1].sid.revision = 1;

                        .anyMatch(a -> a.getName().equals(target.getName()) && a.getVersion().equals(target.getVersion()));
                if (!exists) {
                    ThreadUtil.sleep(500);
                    continue;
                }
                assertTrue("plugin(" + target + ") is included in " + installed, exists);
                done = true;
                break;
            }

            SMBUtil.writeInt4(500, buffer, 8);
            SMBUtil.writeInt4(0, buffer, 12);
            SMBUtil.writeInt4(0, buffer, 16);

            int bytesRead = response.readBytesWireFormat(buffer, 0);

            assertEquals(16, bytesRead);
            assertEquals(1000, response.getCount());
            assertEquals(500, response.getRemaining());
        }

                }
            });

            waiter.start();
            Thread.sleep(50); // Give waiter time to start

            response.received();

            assertTrue(latch.await(500, TimeUnit.MILLISECONDS));
            assertTrue(response.isReceived());
        }

        @Test
        @DisplayName("Should handle async pending status")

    client =
      client
        .newBuilder()
        .callTimeout(250, TimeUnit.MILLISECONDS)
        .build()
    server.enqueue(
      MockResponse
        .Builder()
        .bodyDelay(500, TimeUnit.MILLISECONDS)
        .setHeader("content-type", "text/event-stream")
        .body("data: hey\n\n")
        .build(),
    )
    val source = newEventSource()

        file.createNewFile();
        assertTrue(file.exists(), "File should exist after creation");

        // Ensure proper cleanup before delete
        file.close();
        Thread.sleep(500); // Give more time for handle release
        System.gc(); // Force garbage collection
        Thread.sleep(200);

        // Delete using a completely new context to avoid handle issues