t.Fatalf("expected = %s, got: %s", errFileNotFound, err)
	}

	// Only valid for linux.
	if runtime.GOOS == "linux" {
		permDir := path.Join(os.TempDir(), "perm-dir")
		if err := os.MkdirAll(permDir, os.FileMode(0o200)); err != nil {
			t.Fatal(err)
		}
		defer os.RemoveAll(permDir)

		// Check if permission denied.
		if _, err := readDir(permDir); err == nil {
			t.Fatalf("expected = an error, got: nil")
		}
	}
}

 *
 * @author Alex Matevossian
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
public class XmlEscapers {
  private XmlEscapers() {}

  private static final char MIN_ASCII_CONTROL_CHAR = 0x00;
  private static final char MAX_ASCII_CONTROL_CHAR = 0x1F;

  // For each xxxEscaper() method, please add links to external reference pages
  // that are considered authoritative for the behavior of that escaper.

  /**

        this.flags0 |= fl;
    }

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

        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        // name length without counting null termination
        this.namelen_index = dstIndex;
        dstIndex += 2;
        SMBUtil.writeInt4(this.flags0, dst, dstIndex);

    }

    @Test
    @DisplayName("Test setCommand with various SMB command codes")
    void testSetCommandWithVariousCodes() {
        // Test common SMB command codes
        int[] commandCodes = { 0x00, 0x72, 0x73, 0x74, 0x75, 0xFF };

        for (int command : commandCodes) {
            doNothing().when(messageBlock).setCommand(command);
            when(messageBlock.getCommand()).thenReturn(command);

        ASN1ObjectIdentifier[] mechs = new ASN1ObjectIdentifier[] { OID_KRB_LEGACY };
        int flags = NegTokenInit.REPLAY_DETECTION | NegTokenInit.SEQUENCE_CHECKING;
        byte[] mic = new byte[] { 0x00, 0x0A, (byte) 0xFF };

        NegTokenInit init = new NegTokenInit(mechs, flags, null, mic);
        String s = init.toString();

        assertTrue(s.contains("flags=" + flags), "toString should include flags");

        assertEquals(0, cap.getValue().length, "Optimistic token must be zero-length");
    }

    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x7F, (byte) 0xFF })
    @DisplayName("initSecContext throws on invalid token type")
    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

        void testReadBytesWireFormatSignedByteValue() {
            // Given
            byte[] buffer = new byte[10];
            // Write 4 in little-endian format
            buffer[0] = 0x04;
            buffer[1] = 0x00;

            // When & Then
            assertDoesNotThrow(() -> {
                int bytesRead = response.readBytesWireFormat(buffer, 0);
                assertEquals(4, bytesRead);
            });
        }

        assertArrayEquals(maxFileId, copiedFileId);

        // Test with file ID having minimum byte values
        byte[] minFileId = new byte[16];
        Arrays.fill(minFileId, (byte) 0x00);
        Smb2FlushRequest minRequest = new Smb2FlushRequest(mockConfig, minFileId);

        written = minRequest.writeBytesWireFormat(buffer, 0);

        assertEquals(24, written);

  }

  public void testBase32InvalidDecodings() {
    // These contain bytes not in the decodabet.
    assertFailsToDecode(base32(), "A ", "Unrecognized character: 0x20");
    assertFailsToDecode(base32(), "Wf2!", "Unrecognized character: f");
    // This sentence just isn't base32() encoded.
    assertFailsToDecode(base32(), "let's not talk of love or chains!");

        }

        // Check for control characters
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c < 0x20 && c != '\t' && c != '\r' && c != '\n') {
                failedValidations.incrementAndGet();
                log.warn("{} contains control characters", fieldName);