return 0, &fs.PathError{Op: "read", Path: d.e.name, Err: errors.New("is a directory")}
}

func (d *openDir) ReadDir(count int) ([]fs.DirEntry, error) {
	n := len(d.files) - d.offset
	if count > 0 && n > count {
		n = count
	}
	if n == 0 {
		if count <= 0 {
			return nil, nil
		}
		return nil, io.EOF
	}
	list := make([]fs.DirEntry, n)
	for i := range list {

	// This does not indicate a full scan.
	LastUpdate time.Time `json:"lastUpdate"`

	// Objects total count across all buckets
	ObjectsTotalCount uint64 `json:"objectsCount"`

	// Versions total count across all buckets
	VersionsTotalCount uint64 `json:"versionsCount"`

	// Delete markers total count across all buckets
	DeleteMarkersTotalCount uint64 `json:"deleteMarkersCount"`

	// Objects total size across all buckets

		"Drive health (0 = offline, 1 = healthy, 2 = healing)", allDriveLabels...)

	driveOfflineCountMD = NewGaugeMD(driveOfflineCount,
		"Count of offline drives")
	driveOnlineCountMD = NewGaugeMD(driveOnlineCount,
		"Count of online drives")
	driveCountMD = NewGaugeMD(driveCount,
		"Count of all drives")

	// iostat related
	driveReadsPerSecMD = NewGaugeMD(driveReadsPerSec,
		"Reads per second on a drive",

  private static final @Nullable String NE = null;

  private static <E extends @Nullable Object> Entry<E> entry(E element, int count) {
    return Multisets.immutableEntry(element, count);
  }

  private static <E extends @Nullable Object> Entry<E> control(E element, int count) {
    return HashMultiset.create(nCopies(count, element)).entrySet().iterator().next();
  }

  public void testToString() {

        assertEquals(State.CLOSED, circuitBreaker.getState(), "Initial state should be CLOSED");
        assertEquals(0, circuitBreaker.getFailureCount(), "Initial failure count should be 0");
        assertEquals(0, circuitBreaker.getSuccessCount(), "Initial success count should be 0");
    }

    @Test
    public void testSuccessfulOperation() throws CIFSException {

    }

    /**
     * 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) {

		return
	}

	nerr := unwrapErrs(err)
	l.Lock()
	shouldLog := true
	prev, ok := l.IDMap[id]
	if !ok {
		l.IDMap[id] = onceErr{
			Err:   nerr,
			Count: 1,
		}
	} else if prev.Err.Error() == nerr.Error() {
		// if errors are equal do not log.
		prev.Count++
		l.IDMap[id] = prev
		shouldLog = false
	}
	l.Unlock()

	if shouldLog {
		consoleLogIf(ctx, subsystem, err, errKind...)
	}
}

    /** URL filter for searching failure URLs. */
    //@Maxbytelength(maxbytelength = 1000)
    public String url;

    /** Minimum error count filter for searching failure URLs. */
    //@IntRange(min = 0, max = 2147483647)
    public String errorCountMin;

    /** Maximum error count filter for searching failure URLs. */
    //@IntRange(min = 0, max = 2147483647)
    public String errorCountMax;

    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);
    assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.count()).isEqualTo(2);

    ms.add("a", Integer.MAX_VALUE);
    ms.add("b", Integer.MAX_VALUE);
    ms.add("c", 3);

    assertEquals(Integer.MAX_VALUE, ms.count("a"));
    assertEquals(Integer.MAX_VALUE, ms.count("b"));
    assertEquals(3, ms.count("c"));

    assertEquals(Integer.MAX_VALUE, ms.headMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("b", CLOSED).size());