long total = requestsSent.get();
        if (total == 0)
            return 0.0;
        return (double) errors.get() / total;
    }

    /**
     * Get throughput in bytes per second
     *
     * @return throughput in bps
     */
    public long getThroughput() {
        long duration = System.currentTimeMillis() - establishedTime;
        if (duration == 0)
            return 0;

        }
        return totalReceiveTime.get() / (double) receives / 1000.0; // Convert to microseconds
    }

    /**
     * Calculate total throughput in MB/s based on total time
     *
     * @param totalTimeSeconds total elapsed time in seconds
     * @return throughput in MB/s
     */
    public double getThroughputMBps(double totalTimeSeconds) {
        if (totalTimeSeconds <= 0.0) {
            return 0.0;

    
    SmbFile file = new SmbFile("smb://server/share/largefile.dat", context);
    
    // Measure single channel throughput
    long singleChannelTime = measureReadTime(file, false);
    
    // Measure multi-channel throughput
    long multiChannelTime = measureReadTime(file, true);
    
    // Multi-channel should be faster

- Performance testing infrastructure

## Success Metrics

1. **Functional Completeness**: All features pass Windows Protocol Test Suite
2. **Performance**: 
   - Multi-channel provides >1.5x throughput improvement
   - RDMA reduces latency by >50%
3. **Reliability**: 
   - Persistent handles survive 99% of network interruptions
   - Witness protocol achieves <5 second failover time

	}, nil
}

// To collect RX stats during "mc support perf net"
// RXSample holds the RX bytes for the duration between
// the last peer to connect and the first peer to disconnect.
// This is to improve the RX throughput accuracy.
type netPerfRX struct {
	RX                uint64    // RX bytes
	lastToConnect     time.Time // time at which last peer to connect to us

 * threads. By default, this ordering is not guaranteed. However, a queue constructed with fairness
 * set to {@code true} grants threads access in FIFO order. Fairness generally decreases throughput
 * but reduces variability and avoids starvation.
 *
 * <p>This class and its iterator implement all of the optional methods of the {@link
 * Collection} and {@link Iterator} interfaces.
 *
 * @author Doug Lea

- [ ] Test pagination and sorting
- [ ] Validate security and access control

### Testing

- [ ] Functional testing of search queries
- [ ] Performance testing (response time, throughput)
- [ ] Security testing (authentication, authorization)
- [ ] Integration testing with client applications
- [ ] User acceptance testing
- [ ] Load testing for production capacity

### Go-Live

 *       anything about how the property is tested. To find out, read the code.
 *   <li>These tests are "conformance tests", and do not attempt to test throughput, latency,
 *       scalability or other performance factors (see the separate "jtreg" tests for a set intended
 *       to check these for the most central aspects of functionality.) So, most tests use the

		}, idx, *client.host)
	}
	nerrs := ng.Wait()
	if freeze {
		freezeServices()
	} else {
		unfreezeServices()
	}
	return nerrs
}

// Netperf - perform mesh style network throughput test
func (sys *NotificationSys) Netperf(ctx context.Context, duration time.Duration) []madmin.NetperfNodeResult {
	length := len(sys.allPeerClients)
	if length == 0 {
		// For single node erasure setup.

 *   <li>Lifecycle management using {@code @PostConstruct} and {@code @PreDestroy} annotations</li>
 * </ul>
 *
 * <p>Components can be registered in two ways:
 * <ul>
 *   <li>As singletons, where one instance is shared throughout the container's lifecycle</li>
 *   <li>As prototypes, where a new instance is created each time the component is requested</li>
 * </ul>
 *