class SecurityBlob {

    private byte[] b = {};

    SecurityBlob() {
    }

    SecurityBlob(final byte[] b) {
        set(b);
    }

    void set(final byte[] b) {
        this.b = b == null ? new byte[0] : b;
    }

    byte[] get() {
        return this.b;
    }

    int length() {
        if (this.b == null) {
            return 0;
        }
        return this.b.length;
    }

                && ARTIFACT_ID.equals(artifact.getArtifactId())
                && VERSION.equals(artifact.getVersion())) {
            Model m = new Model();
            m.setArtifactId(ARTIFACT_ID);
            m.setGroupId(GROUP_ID);
            m.setVersion(VERSION);
            Repository repository = new Repository();
            repository.setId(REPO_ID);
            repository.setUrl(REPO_URL);
            repository.setLayout(REPO_LAYOUT);

    public void test_transform() {
        final byte[] data = new String("xyz").getBytes();
        final ResponseData responseData = new ResponseData();
        responseData.setUrl("http://hoge/");
        responseData.setResponseBody(data);
        responseData.setCharSet("ISO-8859-1");
        final ResultData resultData = htmlTransformer.transform(responseData);
        assertEquals("xyz", new String(resultData.getData()));
    }

        // Arrange
        String server = "testServer";
        int access = 123;

        doThrow(new IOException("Network error")).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

        DynamicProperties systemProps = new DynamicProperties(file);
        ComponentUtil.register(systemProps, "systemProperties");

        sambaHelper = new SambaHelper();
    }

    public void test_smb_account() throws SmbException {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override
            public String getSmbAvailableSidTypes() {

                return new URL(protocol + url);
            }
            if (url.startsWith("//")) {
                final String protocol = currentUrl.split(":")[0];
                return new URL(protocol + ":" + url);
            }
            if (url.startsWith("/") || url.indexOf(':') == -1) {
                return new URL(new URL(currentUrl), url);
            }

      Comparator<K0> comparator) {
    checkNotNull(comparator);
    return new MultimapBuilderWithKeys<K0>() {
      @Override
      <K extends K0, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return new TreeMap<>(comparator);
      }
    };
  }

  /**
   * Uses an {@link EnumMap} to map keys to value collections.
   *

      Comparator<K0> comparator) {
    checkNotNull(comparator);
    return new MultimapBuilderWithKeys<K0>() {
      @Override
      <K extends K0, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return new TreeMap<>(comparator);
      }
    };
  }

  /**
   * Uses an {@link EnumMap} to map keys to value collections.
   *

        // Test with empty list
        List<Map<String, Object>> emptyList = new ArrayList<>();
        searchRenderData.setDocumentItems(emptyList);
        assertEquals(emptyList, searchRenderData.getDocumentItems());

        // Test with populated list
        List<Map<String, Object>> documentItems = new ArrayList<>();
        Map<String, Object> doc1 = new HashMap<>();
        doc1.put("title", "Test Document 1");

     * .
     */
    @Test
    public void testSUnsupportedOperationExceptionStringThrowable() {
        final ClUnsupportedOperationException clUnsupportedOperationException =
                new ClUnsupportedOperationException("hoge", new NullPointerException());
        assertThat(clUnsupportedOperationException.getMessage(), is("hoge"));
        assertThat(clUnsupportedOperationException.getCause(), instanceOf(NullPointerException.class));
    }