random.nextBytes(bytes);
      String s = new String(bytes, UTF_16LE); // so all random strings are valid
      assertEquals(
          new TestHasher().putUnencodedChars(s).hash(),
          new TestHasher().putBytes(s.getBytes(UTF_16LE)).hash());
      assertEquals(
          new TestHasher().putUnencodedChars(s).hash(),
          new TestHasher().putString(s, UTF_16LE).hash());
    }
  }

  public void testFloat() {

      suite.addTest(stringSuite);
    }
    return suite;
  }

  private static TestSuite suiteForString(
      String name, ByteSinkFactory factory, String string, String desc) {
    byte[] bytes = string.getBytes(UTF_8);
    TestSuite suite = suiteForBytes(name, factory, desc, bytes);
    CharSinkFactory charSinkFactory = SourceSinkFactories.asCharSinkFactory(factory);
    suite.addTest(
        CharSinkTester.suiteForString(

        assertTrue(content.contains("タイトル2"));
        assertTrue(content.contains("リンク1"));
    }

    public void test_getHtml_empty() {
        final InputStream in = new ByteArrayInputStream("".getBytes());
        final String content = htmlXpathExtractor.getText(in, null).getContent();
        CloseableUtil.closeQuietly(in);
        logger.info(content);
        assertEquals("", content);
    }

        try ( SmbResource f = getDefaultShareRoot() ) {
            checkConnection(f);
            if ( f.getType() != SmbConstants.TYPE_FILESYSTEM ) {
                assertEquals(SmbConstants.TYPE_SHARE, f.getType());
            }
        }
    }


    @Test
    public void testGetFreeSpace () throws CIFSException, MalformedURLException {

                    final String converted = URLEncoder.encode(target, Constants.UTF_8);
                    if (target.equals(converted)) {
                        encodedBuf.append(Base64.getUrlEncoder().encodeToString(target.getBytes(Constants.CHARSET_UTF_8)));
                    } else {
                        encodedBuf.append(converted);
                    }
                } catch (final UnsupportedEncodingException e) {

      random.nextBytes(bytes);
      String s = new String(bytes, UTF_16LE); // so all random strings are valid
      assertEquals(
          new Sink(4).putUnencodedChars(s).hash(),
          new Sink(4).putBytes(s.getBytes(UTF_16LE)).hash());
      assertEquals(
          new Sink(4).putUnencodedChars(s).hash(), new Sink(4).putString(s, UTF_16LE).hash());
    }
  }

  public void testFloat() {
    Sink sink = new Sink(4);

                            try (InputStream contentStream = new BufferedInputStream(new FileInputStream(file))) {
                                responseData.setResponseBody(InputStreamUtil.getBytes(contentStream));
                            } catch (final Exception e) {
                                logger.warn("I/O Exception.", e);

            update(data, offset, length);
            System.arraycopy(digest(), 0, data, index, 8);
            if (bypass) {
                bypass = false;
                System.arraycopy("BSRSPYL ".getBytes(), 0, data, index, 8);
            }
        } catch (Exception ex) {
            if( log.level > 0 )
                ex.printStackTrace( log );
        } finally {
            signSequence += 2;
        }

    public SecurityDescriptor ( byte[] buffer, int bufferIndex, int len ) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }


    /**
     * @return the type
     */
    public final int getType () {
        return this.type;
    }


    /**
     * @return the aces
     */
    public final ACE[] getAces () {
        return this.aces;
    }


    /**
     * @return the ownerGroupSid

    protected MavenMetadata(Metadata metadata, Path path, Date timestamp) {
        this.metadata = metadata;
        this.path = path;
        this.timestamp = timestamp;
    }

    @Override
    public String getType() {
        return MAVEN_METADATA_XML;
    }

    @Deprecated
    @Override
    public File getFile() {
        return path != null ? path.toFile() : null;
    }

    @Override