request = new Smb2CreateRequest(mockConfig, "test.txt");

        request.setSecurityFlags((byte) 0x01);
        // Verify through writeBytesWireFormat
        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, 0);
        assertEquals((byte) 0x01, buffer[2]);
    }

    @Test
    @DisplayName("Test oplock level setter")
    void testSetRequestedOplockLevel() {

        verifyNfold("012345", 8,
                new byte[] { (byte) 0xbe, (byte) 0x07, (byte) 0x26, (byte) 0x31, (byte) 0x27, (byte) 0x6b, (byte) 0x19, (byte) 0x55 });

        // 56-fold("password")
        verifyNfold("password", 7,
                new byte[] { (byte) 0x78, (byte) 0xa0, (byte) 0x7b, (byte) 0x6c, (byte) 0xaf, (byte) 0x85, (byte) 0xfa });

        // 64-fold("Rough Consensus, and Running Code")

        return dstIndex - start;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x01; /* BufferFormat */
        dstIndex++;
        SMBUtil.writeInt2(this.count, dst, dstIndex); /* DataLength? */
        dstIndex += 2;
        System.arraycopy(this.b, this.off, dst, dstIndex, this.count);

        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */

            assertThat(b).isEqualTo(2.toByte())
          }
        }
      },
    )
  }

  @Test fun dataFrameNotAssociateWithStream() {
    val payload = byteArrayOf(0x01, 0x02)
    writeMedium(frame, payload.size)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0)
    frame.write(payload)
    assertFailsWith<IOException> {

    // Mixed string
    // "a\u020ac\u00a2b\\u024B62u020acc\u00a2de\u024B62"
    assertWellFormed(
        0x61, 0xc8, 0x8a, 0x63, 0xc2, 0xa2, 0x62, 0x5c, 0x75, 0x30, 0x32, 0x34, 0x42, 0x36, 0x32,
        0x75, 0x30, 0x32, 0x30, 0x61, 0x63, 0x63, 0xc2, 0xa2, 0x64, 0x65, 0xc9, 0x8b, 0x36, 0x32);
    // Not a valid string
    assertNotWellFormed(-1, 0, -1, 0);
  }

  public void testShardsHaveExpectedRoundTrippables() {

        // Act
        int bytesWritten = write.writeBytesWireFormat(dst, 0);

        // Assert
        assertEquals(6, bytesWritten, "Should write 6 bytes (1 type + 2 length + 3 data)");
        assertEquals(0x01, dst[0], "Data block type");
        assertEquals(3, dst[1] & 0xFF, "Data length low byte");
        assertEquals(0, dst[2] & 0xFF, "Data length high byte");
        assertEquals(2, dst[3], "First data byte");

        this.domain = domain;
        this.serverTypes = serverTypes;
        this.name = "\\PIPE\\LANMAN";

        this.maxParameterCount = 8;
        this.maxDataCount = 16384;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 0;
        this.timeout = 5000;
    }

    @Override
    public void reset(final int key, final String lastN) {
        super.reset();
        this.lastName = lastN;
    }

    /** Maximum supported SMB Direct protocol version (1.0) */
    public static final int MAX_VERSION = 0x0100; // SMB Direct 1.0
    /** SMB Direct negotiate request message type */
    public static final int NEGOTIATE_REQUEST = 0x01;

    // Message fields
    private int minVersion = MIN_VERSION;
    private int maxVersion = MAX_VERSION;
    private int reserved = 0;
    private int creditsRequested = RdmaCapabilities.DEFAULT_SEND_CREDIT_TARGET;

            // When: Creating close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // Then: Should have correct opnum and handle
            assertEquals(0x01, message.getOpnum());
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test
        @DisplayName("Should encode input parameters correctly")