*/
    public TransWaitNamedPipe(final Configuration config, final String pipeName) {
        super(config, SMB_COM_TRANSACTION, TRANS_WAIT_NAMED_PIPE);
        this.name = pipeName;
        this.timeout = 0xFFFFFFFF;
        this.maxParameterCount = 0;
        this.maxDataCount = 0;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
    }

    @Override

                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, // 0xFFFFFFFF
                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // 0x00000000
                (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x89 // 0x89ABCDEF
        };

        assertEquals(0x12345678, SMBUtil.readInt4(src, 0));
        assertEquals(0xFFFFFFFF, SMBUtil.readInt4(src, 4));
        assertEquals(0x00000000, SMBUtil.readInt4(src, 8));

 */

package jcifs.smb1.smb1;

import java.io.UnsupportedEncodingException;

class NetServerEnum2 extends SmbComTransaction {

    static final int SV_TYPE_ALL = 0xFFFFFFFF;
    static final int SV_TYPE_DOMAIN_ENUM = 0x80000000;

    static final String[] DESCR = { "WrLehDO\u0000B16BBDz\u0000", "WrLehDz\u0000B16BBDz\u0000", };

    String domain, lastName = null;
    int serverTypes;

    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }
  }

  public void testDecodeInt() {
    assertThat(UnsignedInts.decode("0xffffffff")).isEqualTo(0xffffffff);
    assertThat(UnsignedInts.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedInts.decode("#12345678")).isEqualTo(0x12345678);

    }

    @ParameterizedTest
    @DisplayName("Test writeParametersWireFormat with various server types")
    @ValueSource(ints = { 0x00000000, 0x00000001, 0x00000801, 0x80000000, 0xFFFFFFFF })
    void testWriteParametersWireFormatVariousServerTypes(int serverType) {
        String domain = "DOMAIN";
        netServerEnum2 = new NetServerEnum2(realConfig, domain, serverType);

     */
    @Test
    void testGetMessageByDcerpcError_smallerThanAny() {
        int unknownCode = -1;
        String message = DcerpcException.getMessageByDcerpcError(unknownCode);
        assertEquals("0xFFFFFFFF", message, "Should return hex string for code smaller than any known.");
    }

    /**
     * Test getMessageByDcerpcError() with an error code larger than any known.

     * @param value true to set the flag, false to clear it
     */
    public void setContextFlag(final int flag, final boolean value) {
        setContextFlags(value ? getContextFlags() | flag : getContextFlags() & (0xffffffff ^ flag));
    }

    /**
     * Gets the array of supported authentication mechanisms
     * @return the mechanisms array
     */
    public ASN1ObjectIdentifier[] getMechanisms() {

        super(config, SMB_COM_TRANSACTION, TRANS_CALL_NAMED_PIPE);
        this.name = pipeName;
        this.pipeData = data;
        this.pipeDataOff = off;
        this.pipeDataLen = len;
        this.timeout = 0xFFFFFFFF;
        this.maxParameterCount = 0;
        this.maxDataCount = 0xFFFF;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
    }

    @Override

        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")
    void testReadInt2() {
        byte[] src = { (byte) 0x12, (byte) 0x34, (byte) 0x56 };

    void testDefaultFlags() {
        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test