long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;

        // Then - should complete quickly (this is more of a performance indicator)
        assertTrue(duration < 1000, "Creating and using 10000 EmptyIterators should be fast (took " + duration + "ms)");
    }

    @Test
    @DisplayName("EmptyIterator should work correctly in nested iteration")
    void testNestedIteration() {

        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);
        byte[] smallBuffer = new byte[1];
        byte[] largeBuffer = new byte[1000];

        // Act & Assert
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(smallBuffer, 0, 1));
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(largeBuffer, 500, 500));

        trans2FindNext2 = new Trans2FindNext2(config, TEST_SID, TEST_RESUME_KEY, TEST_FILENAME, TEST_BATCH_COUNT, TEST_BATCH_SIZE);

        for (int i = 1; i <= 5; i++) {
            int newResumeKey = i * 1000;
            String newFilename = "file" + i + ".txt";

            trans2FindNext2.reset(newResumeKey, newFilename);

            byte[] buffer = new byte[256];

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write a RID (4 bytes) for readId() method
        writeLittleEndianInt(dos, 1000);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        PacDataInputStream pacStream = new PacDataInputStream(bais);

        SID id = pacStream.readId();

		expectedStrings []string
	}{
		{getListObjectsV1URL(s.endPoint, bucketName, "", "1000", ""), []string{"<Key>foo bar 1</Key>", "<Key>foo bar 2</Key>"}},
		{getListObjectsV1URL(s.endPoint, bucketName, "", "1000", "url"), []string{"<Key>foo+bar+1</Key>", "<Key>foo+bar+2</Key>"}},
		{
			getListObjectsV2URL(s.endPoint, bucketName, "", "1000", "", "", ""),
			[]string{
				"<Key>foo bar 1</Key>",
				"<Key>foo bar 2</Key>",

            rn = resp.numReferrals;
        }

        DfsReferral dr = new DfsReferral();

        final String[] arr = new String[4];
        final long expiration = System.currentTimeMillis() + Dfs.TTL * 1000;

        int di = 0;
        for (;;) {
            /* NTLM HTTP Authentication must be re-negotiated
             * with challenge from 'server' to access DFS vol. */

  }

  @Test fun `decode negative integer`() {
    val bytes = "02019c".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(-100L)
    assertThat(Adapters.INTEGER_AS_LONG.toDer(-100L)).isEqualTo(bytes)
  }

  @Test fun `five byte integer`() {
    val bytes = "02058000000001".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(-549755813887L)

        nf.setMaximumIntegerDigits(2);
        nf.setMaximumFractionDigits(2);
        String execTime;
        try {
            execTime = nf.format((double) queryResponseList.getExecTime() / 1000);
        } catch (final Exception e) {
            execTime = StringUtil.EMPTY;
        }
        data.setExecTime(execTime);

        final String queryId = ComponentUtil.getQueryHelper().generateId();

                                               value="${f:h(numOfThread)}" class="form-control"
                                               min="1" max="1000">
                                    </div>
                                </div>
                                <div class="form-group row">

        }

        @Test
        void shouldReturnInetAddressFromWrappedAddressWhenWrappedIsAddress() throws UnknownHostException {
            InetAddress expectedInetAddress = InetAddress.getByName("10.0.0.1");
            when(mockAddress.toInetAddress()).thenReturn(expectedInetAddress);
            UniAddress uniAddress = new UniAddress(mockAddress);
            assertEquals(expectedInetAddress, uniAddress.toInetAddress());