String result = viewHelper.removeHighlightTag(text);
        assertEquals("highlighted text", result);

        text = "normal text";
        result = viewHelper.removeHighlightTag(text);
        assertEquals("normal text", result);

        text = "";
        result = viewHelper.removeHighlightTag(text);
        assertEquals("", result);
    }

                case COMBINATION_ITEM:
                    int result = this.compareTo(((CombinationItem) item).getStringPart());
                    if (result == 0) {
                        return -1;
                    }
                    return result;

                case LIST_ITEM:
                    return -1; // 1.any < 1-1

                default:

        // Arrange
        SmbPipeOutputStream out = newStream();
        when(handle.isOpen()).thenReturn(state);

        // Act
        boolean result = out.isOpen();

        // Assert
        assertEquals(state, result, "isOpen should reflect handle state");
        verify(handle, times(1)).isOpen();
    }

    @Test
    @DisplayName("ensureTreeConnected delegates and returns the tree handle")

        String result = cmd.toString();
        assertTrue(result.startsWith("NtTransQuerySecurityDesc["), "toString should start with class name");
        String hexFid = String.format("%04X", fid & 0xFFFF);
        String hexSec = String.format("%08X", securityInformation & 0xFFFFFFFFL);
        assertTrue(result.contains("fid=0x" + hexFid), () -> "Expected hex fid " + hexFid + " in: " + result);

            public String getCanonicalLdapName(String name) {
                return name;
            }
        });
        sambaHelper.init();

        String result = sambaHelper.createSearchRole(1, "TestUser");
        assertEquals("1testuser", result);
    }

    @Test
    public void test_createSearchRole_keepCase() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override

            final List<Map<String, String>> result = new ArrayList<>();
            final Map<String, String> map = new HashMap<>();
            map.put("id", UPLOAD);
            map.put("name", "");
            map.put("version", "");
            result.add(map);
            try {
                result.addAll(getAllAvailableArtifacts());
            } catch (final Exception e) {

  val result = Buffer()
  var i = 0
  while (i < address.size) {
    if (i == longestRunOffset) {
      result.writeByte(':'.code)
      i += longestRunLength
      if (i == 16) result.writeByte(':'.code)
    } else {
      if (i > 0) result.writeByte(':'.code)
      val group = address[i] and 0xff shl 8 or (address[i + 1] and 0xff)
      result.writeHexadecimalUnsignedLong(group.toLong())

            String result = buffer.toString();

            assertNotNull(result);
            assertTrue(result.contains("pathConsumed=10"));
            assertTrue(result.contains("numReferrals=1"));
            assertTrue(result.contains("flags=15"));
            assertTrue(result.contains("referrals=["));
            assertFalse(result.contains("referrals=[]"));
        }
    }

                }))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Create a new protected words entry for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param body create request payload
     * @return JSON response containing creation result and new entry ID
     */
    // POST /api/admin/dict/protwords/setting/{dictId}

        implements ProjectArtifactsCache.ArtifactsSetWithResult {
    final DependencyResolutionResult result;
    final Set<Artifact> artifacts;

    public SetWithResolutionResult(DependencyResolutionResult result, Set<Artifact> artifacts) {
        this.result = result;
        this.artifacts = Collections.unmodifiableSet(artifacts);
    }

    @Override
    public Iterator<Artifact> iterator() {