}

  /** Returns the number of bytes written. */
  public long getCount() {
    return count;
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    out.write(b, off, len);
    count += len;
  }

  @Override
  public void write(int b) throws IOException {
    out.write(b);
    count++;
  }

     * @return the integer value of the hex digits
     */
    public static int hex_to_bin(final char[] arr, final int offset, final int length) {
        int value = 0;
        int ai, count;

        count = 0;
        for (ai = offset; ai < arr.length && count < length; ai++) {
            value <<= 4;
            switch (arr[ai]) {
            case '0':
            case '1':
            case '2':
            case '3':

	handle, err := syscall.FindFirstFile(globAllP, data)
	if err != nil {
		return nil, syscallErrToFileErr(dirPath, err)
	}

	defer syscall.FindClose(handle)

	count := opts.count
	for ; count != 0; err = syscall.FindNextFile(handle, data) {
		if err != nil {
			if err == syscall.ERROR_NO_MORE_FILES {
				break
			}
			return nil, osErrToFileErr(&os.PathError{
				Op:   "FindNextFile",

    }

    /**
     * Gets the total number of records.
     * @return The total record count.
     */
    public int getAllRecordCount() {
        return allRecordCount;
    }

    /**
     * Sets the total number of records.
     * @param allRecordCount The total record count.
     */
    public void setAllRecordCount(final int allRecordCount) {
        this.allRecordCount = allRecordCount;

    ms.add(Color.RED);
    assertEquals(0, ms.count(Color.BLUE));
    assertEquals(1, ms.count(Color.YELLOW));
    assertEquals(2, ms.count(Color.RED));
  }

  public void testCollectionCreate() {
    Multiset<Color> ms = EnumMultiset.create(asList(Color.RED, Color.YELLOW, Color.RED));
    assertEquals(0, ms.count(Color.BLUE));
    assertEquals(1, ms.count(Color.YELLOW));
    assertEquals(2, ms.count(Color.RED));
  }

  var complete = (upstream == null)

  /** The most recently read bytes from [upstream]. This is a suffix of [file]. Guarded by this. */
  val buffer = Buffer()

  /**
   * Reference count of the number of active sources reading this stream. When decremented to 0
   * resources are released and all following calls to [.newSource] return null. Guarded by this.
   */
  var sourceCount = 0

  val isClosed: Boolean

      }
    } while (System.nanoTime() - deadline < 0);
    throw formatRuntimeException(
        "Latch failed to count down within %d second timeout", timeoutSeconds);
  }

  /**
   * Creates a garbage object that counts down the latch in its finalizer. Sequestered into a
   * separate method to make it somewhat more likely to be unreachable.
   */

            count = new AtomicInteger(1);
        }

        /**
         * Increments the reference count for this statistics object.
         *
         * @return the new reference count after incrementing
         */
        public int increment() {
            return count.incrementAndGet();
        }

        /**
         * Decrements the reference count for this statistics object.
         *

        assertEquals("term2", result.get(1).getTerm());
    }

    public void test_load_emptyList() {
        mockBhv.setTestData(new ArrayList<>());

        int count = relatedContentHelper.load();
        assertEquals(0, count);

        String[] results = relatedContentHelper.getRelatedContents("anyterm");
        assertEquals(0, results.length);
    }

    public void test_load_simpleTerms() {

   *
   * @param string any non-null string
   * @param count the number of times to repeat it; a nonnegative integer
   * @return a string containing {@code string} repeated {@code count} times (the empty string if
   *     {@code count} is zero)
   * @throws IllegalArgumentException if {@code count} is negative
   */
  public static String repeat(String string, int count) {
    checkNotNull(string); // eager for GWT.