if (TRAVERSAL_PATTERN.matcher(path).find()) {
            return true;
        }

        // Check encoded traversals
        if (ENCODED_TRAVERSAL.matcher(path).find()) {
            return true;
        }

        // Check Unicode encoded traversals
        if (UNICODE_TRAVERSAL.matcher(path).find()) {
            return true;
        }

        verify(transport, times(4)).close();
    }

    @Test
    @DisplayName("isSMB2 true and exception fallback to false")
    void isSMB2Cases() throws Exception {
        // Happy path returns true; transport exception path returns false
        when(transport.isSMB2()).thenReturn(true);
        assertTrue(handle.isSMB2());

        reset(transport);

     */
    public void testSetXIncludeAware() throws Exception {
        final SAXParserFactory spf = SAXParserFactoryUtil.newInstance();
        SAXParserFactoryUtil.setXIncludeAware(spf, true);
        spf.setNamespaceAware(true);
        final SAXParser parser = SAXParserFactoryUtil.newSAXParser(spf);

        final InputSource is = new InputSource(ResourceUtil.getResourceAsStream("org/codelibs/core/xml/include.xml"));

												href="#" role="button" aria-haspopup="true" aria-expanded="false"
											> <em class="fa fa-fw fa-user">${username}
											</a>
											<div class="dropdown-menu" aria-labelledby="userMenu">
												<c:if test="${editableUser == true}">
													<la:link href="/profile" styleClass="dropdown-item">
														<la:message key="labels.profile" />

    void hasCapability_variousCaps_returnsTrue_andCapturesArgument(int cap) throws Exception {
        // Arrange: stub to return true regardless of input
        when(handle.hasCapability(anyInt())).thenReturn(true);

        // Act
        boolean result = handle.hasCapability(cap);

        // Assert: verify return and the captured argument equals input
        assertTrue(result);

    @BeforeEach
    void setUp() {
        resourceManager = ResourceManager.getInstance();
        // Configure with shorter intervals for testing
        resourceManager.configure(1000, 100, true, true);
    }

    /**
     * Test resource for tracking
     */
    static class TestResource implements AutoCloseable {
        private final AtomicBoolean closed = new AtomicBoolean(false);

   *
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)

      assertFalse(runCalled);
      assertFalse(shutDownCalled);
      startUpCalled = true;
      assertEquals(State.STARTING, state());
    }

    @Override
    protected void run() {
      assertTrue(startUpCalled);
      assertFalse(runCalled);
      assertFalse(shutDownCalled);
      runCalled = true;
      assertEquals(State.RUNNING, state());

      enterRun.countDown();
      try {

    true_strings = ('1', 't', 'true', 'y', 'yes')
    false_strings = ('0', 'f', 'false', 'n', 'no')
    if var_content in true_strings:
      var = True
    elif var_content in false_strings:
      var = False
    else:
      raise UserInputError(
          'Environment variable %s must be set as a boolean indicator.\n'
          'The following are accepted as TRUE : %s.\n'

			expectedErr:    false,
			expectedUpdate: true,
		},
		{
			meta:           meta,
			pools:          reducedPools,
			name:           "Correct-Update",
			expectedErr:    false,
			expectedUpdate: true,
		},
		{
			meta:           meta,
			pools:          orderChangePools,
			name:           "Invalid-Orderchange",
			expectedErr:    false,
			expectedUpdate: true,
		},
		{
			meta:           nmeta1,