long startTime = System.nanoTime();
                        boolean result = correctAuth.equals(wrongAuth);
                        long endTime = System.nanoTime();
                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }
                });
            }

                } catch (CIFSException e) {
                    throw new RuntimeException(e);
                }
            });
        }

        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;

        // Then - should complete quickly (this is more of a performance indicator)

            }
        });
        testThread.start();

        long startTime = System.currentTimeMillis();
        method.invoke(crawler, testThread);
        long endTime = System.currentTimeMillis();

        assertTrue("Thread should have been joined", endTime - startTime >= 100);
    }

    // Test destroyContainer private static method via reflection
    public void test_destroyContainer() throws Exception {

		elapsed := time.Since(ps.Info.StartTime)
		eta := time.Duration(totalBytesToRebal * float64(elapsed) / float64(ps.Bytes))
		if !ps.Info.EndTime.IsZero() {
			stopTime = ps.Info.EndTime
		}

		if !stopTime.IsZero() { // rebalance is stopped or completed
			elapsed = stopTime.Sub(ps.Info.StartTime)
			eta = 0
		}

		r.Pools[i].Progress = rebalPoolProgress{

	defer periodicTimer.Stop()

	for {
		select {
		case <-periodicTimer.C:
			now := UTCNow()
			ahs.Lock()
			for path, h := range ahs.healSeqMap {
				if h.hasEnded() && h.endTime.Add(keepHealSeqStateDuration).Before(now) {
					delete(ahs.healSeqMap, path)
				}
			}
			ahs.Unlock()

			periodicTimer.Reset(time.Minute * 5)
		case <-ctx.Done():

type ResyncTarget struct {
	Arn       string    `json:"arn"`
	ResetID   string    `json:"resetid"`
	StartTime time.Time `json:"startTime"`
	EndTime   time.Time `json:"endTime"`
	// Status of resync operation
	ResyncStatus string `json:"resyncStatus,omitempty"`
	// Completed size in bytes
	ReplicatedSize int64 `json:"completedReplicationSize"`
	// Failed size in bytes

            long startTime = System.nanoTime();
            info.decode(largeBuffer, 0, 24);
            long endTime = System.nanoTime();

            // Should complete quickly (under 1ms)
            assertTrue((endTime - startTime) < 1_000_000);
        }

        @ParameterizedTest
        @ValueSource(ints = { 24, 32, 100, 1000, 10000 })

const (
	rebalNone rebalStatus = iota
	rebalStarted
	rebalCompleted
	rebalStopped
	rebalFailed
)

type rebalanceInfo struct {
	StartTime time.Time   `msg:"startTs"` // Time at which rebalance-start was issued
	EndTime   time.Time   `msg:"stopTs"`  // Time at which rebalance operation completed or rebalance-stop was called
	Status    rebalStatus `msg:"status"`  // Current state of rebalance operation. One of Started|Stopped|Completed|Failed.
}

                    }
                });
            }

            startLatch.countDown();
            boolean completed = endLatch.await(10, TimeUnit.SECONDS);
            long endTime = System.currentTimeMillis();
            executor.shutdown();

            assertTrue(completed, "All verify operations should complete");