DB.Create(&users)

	rows, err := DB.Select("name, count(*) as total").Table("users").Group("name").Having("name IN ?", []string{users[0].Name, users[1].Name}).Rows()
	if err != nil {
		t.Fatalf("got error %v", err)
	}

	defer rows.Close()
	for rows.Next() {
		var name string
		var total int64
		rows.Scan(&name, &total)

		if name == users[0].Name && total != 3 {

        // Word count
        buffer[32] = 10; // 10 words = 20 bytes

        // Parameter words for transaction response
        // Total parameter count (2 bytes)
        buffer[33] = 0x00;
        buffer[34] = 0x00;

        // Total data count (2 bytes)
        buffer[35] = 0x00;
        buffer[36] = 0x00;

        // Reserved (2 bytes)
        buffer[37] = 0x00;

		}
		return
	}
	xls := xlStorage{drivePath: base, diskInfoCache: cachevalue.New[DiskInfo]()}
	xls.diskInfoCache.InitOnce(time.Second, cachevalue.Opts{}, func(ctx context.Context) (DiskInfo, error) {
		return DiskInfo{Total: 1 << 40, Free: 1 << 40}, nil
	})
	weSleep := func() bool { return false }

	got, err := scanDataFolder(t.Context(), nil, &xls, dataUsageCache{Info: dataUsageCacheInfo{Name: bucket}}, getSize, 0, weSleep)
	if err != nil {

		size = diskAssumeUnknownSize
	}

	var available uint64
	var total uint64
	var nDisks int
	for _, disk := range di {
		if disk == nil || disk.Total == 0 {
			// Disk offline, no inodes or something else is wrong.
			continue
		}
		nDisks++
		total += disk.Total
		available += disk.Total - disk.Used
	}

	if nDisks < len(di)/2 || nDisks <= 0 {
		var errs []error

        public long getLastActivityTime() {
            return lastActivityTime;
        }

        public double getSuccessRate() {
            long total = successCount.get() + failureCount.get();
            return total > 0 ? (double) successCount.get() / total : 1.0;
        }
    }

    /**
     * Pool health metrics for monitoring
     */
    public static class PoolHealthMetrics {

    /**
     * Gets the number of chunks successfully written
     * @return the chunksWritten
     */
    public int getChunksWritten() {
        return this.chunksWritten;
    }

    /**
     * Gets the total number of bytes written in the copy operation
     * @return the totalBytesWritten
     */
    public int getTotalBytesWritten() {
        return this.totalBytesWritten;
    }

    /**
     * {@inheritDoc}

        @CsvSource({ "1048576, 524288, 8, 512, 4294967296, 2147483648", // 4GB total, 2GB free
                "2097152, 1048576, 8, 512, 8589934592, 4294967296", // 8GB total, 4GB free
                "134217728, 67108864, 8, 512, 549755813888, 274877906944", // 512GB total, 256GB free
                "1, 1, 1, 1, 1, 1", // Minimal values
                "0, 0, 1, 1, 0, 0" // Zero allocation units

            timeout=urllib3.Timeout.DEFAULT_TIMEOUT,
            maxsize=10,
            cert_reqs='CERT_NONE',
            ca_certs=ca_certs,
            retries=urllib3.Retry(
                total=5,
                backoff_factor=0.2,
                status_forcelist=[500, 502, 503, 504]
            )
        )

    def load(self):
        """
        Search for credentials with client_grants

     * Returns the similar document hash.
     *
     * @return The similar document hash.
     */
    public abstract String getSimilarDocHash();

    /**
     * Returns the track total hits.
     *
     * @return The track total hits.
     */
    public String getTrackTotalHits() {
        return null;
    }

    /**
     * Returns the min score.
     *
     * @return The min score.
     */

	// Completed size in bytes
	ReplicatedSize int64 `json:"completedReplicationSize"`
	// Failed size in bytes
	FailedSize int64 `json:"failedReplicationSize"`
	// Total number of failed operations
	FailedCount int64 `json:"failedReplicationCount"`
	// Total number of failed operations
	ReplicatedCount int64 `json:"replicationCount"`
	// Last bucket/object replicated.
	Bucket string `json:"bucket,omitempty"`