}

  @Test
  @Throws(Exception::class)
  fun parseNonStandardStrings() {
    // RFC 822, updated by RFC 1123 with any TZ
    assertThat("Thu, 01 Jan 1970 00:00:00 GMT-01:00".toHttpDateOrNull()!!.time).isEqualTo(3600000L)
    assertThat("Thu, 01 Jan 1970 00:00:00 PST".toHttpDateOrNull()!!.time).isEqualTo(28800000L)
    // Ignore trailing junk

        ByteBuffer bb = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
        bb.putShort((short) fid);
        bb.put((byte) 0x00); // Reserved
        bb.put((byte) 0x00); // Reserved
        bb.putInt(securityInformation);
        return bb.array();
    }

    /**
     * Provide a range of values that are valid for the constructor.
     */

    assertThat(max(LEAST)).isEqualTo(LEAST);
    assertThat(max(GREATEST)).isEqualTo(GREATEST);
    assertThat(max(8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0)).isEqualTo(9.0);

    assertThat(max(-0.0, 0.0)).isEqualTo(0.0);
    assertThat(max(0.0, -0.0)).isEqualTo(0.0);
    assertThat(max(NUMBERS)).isEqualTo(GREATEST);
    assertThat(Double.isNaN(max(VALUES))).isTrue();
  }

  @GwtIncompatible
  public void testMin_noArgs() {

            dstIndex++;
            dst[dstIndex++] = (byte) 0x00; // Reserved1
            SMBUtil.writeInt2(this.tflags, dst, dstIndex);
            dstIndex += 2;
            SMBUtil.writeInt4(this.timeout, dst, dstIndex);
            dstIndex += 4;
            dst[dstIndex++] = (byte) 0x00; // Reserved2
            dst[dstIndex++] = (byte) 0x00;
        }
        SMBUtil.writeInt2(this.parameterCount, dst, dstIndex);

        isBroadcast = false;
    }

    @Override
    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        final int tmp = questionName.hexCode;
        questionName.hexCode = 0x00; // type has to be 0x00 for node status
        final int result = writeQuestionSectionWireFormat(dst, dstIndex);
        questionName.hexCode = tmp;
        return result;
    }

    @Override

        byte[] buffer = new byte[100];

        // Define behavior
        when(mockFileInfo.decode(buffer, 0, 100)).thenReturn(8);

        // Test decode
        int decoded = mockFileInfo.decode(buffer, 0, 100);
        assertEquals(8, decoded);

        // Verify interaction
        verify(mockFileInfo).decode(buffer, 0, 100);
    }

    /**
     * Test FileInformation as Encodable
     */
    @Test

            }
        } else {
            // no password in tree connect
            passwordLength = 1;
        }

        dst[dstIndex] = disconnectTid ? (byte) 0x01 : (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        writeInt2(passwordLength, dst, dstIndex);
        return 4;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {

        } else {
            this.path = filename + "\\";
        }
        this.wildcard = wildcard;
        this.searchAttributes = searchAttributes & 0x37; /* generally ignored tho */

        this.tflags = 0x00;
        this.informationLevel = SMB_FILE_BOTH_DIRECTORY_INFO;

        this.totalDataCount = 0;
        this.maxParameterCount = 10;
        this.maxItems = batchCount;
        this.maxDataCount = batchSize;

    void testConstructor() throws Exception {
        Trans2GetDfsReferral cmd = new Trans2GetDfsReferral("/file");
        assertEquals("/file", getPrivateField(cmd, "path"));
        assertEquals((byte) 0x00, getPrivateField(cmd, "maxSetupCount"));
        assertEquals(4096, getPrivateField(cmd, "maxDataCount"));
    }

    @Test
    @DisplayName("writeSetupWireFormat writes subCommand and padding")

@DisplayName("Hexdump Utility Tests")
class HexdumpTest extends BaseTest {

    @Test
    @DisplayName("Should convert byte array to hex string")
    void testToHexString() {
        // Given
        byte[] data = { 0x00, 0x0F, (byte) 0xFF, 0x7F, (byte) 0x80 };

        // When
        String result = Hexdump.toHexString(data);

        // Then
        assertNotNull(result);
        assertEquals("000FFF7F80", result);
    }