(this as Object).wait(timeoutMillis - nowMillis)
    }

    throw AssertionError("Timed out waiting for response to $url")
  }

  companion object {
    val TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(10)
  }

    public int compare(@Nullable String first, @Nullable String second) {
      if (first == second) {
        return 0;
      } else if (first == null) {
        return -1;
      } else if (second == null) {
        return 1;
      } else if (first.length() != second.length()) {
        return first.length() - second.length();
      } else {
        return first.compareTo(second);
      }
    }
  }

                }
            });
        }

        // Start all threads at once
        startLatch.countDown();

        // Wait for completion
        assertTrue(doneLatch.await(5, TimeUnit.SECONDS), "Threads did not complete in time");
        executor.shutdown();

        // Verify hash is not null
        byte[] hash = transport.getPreauthIntegrityHash();
        assertNotNull(hash);

        }
      }
    }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String =
    logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")

        ByteBuffer buffer = ByteBuffer.allocate(200);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // First notification with nextEntryOffset pointing to second
        int secondOffset = 48;
        buffer.putInt(secondOffset); // nextEntryOffset to second entry
        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        String fileName1 = "first.txt";
        byte[] fileNameBytes1 = fileName1.getBytes("UTF-16LE");

    private static final int DEFAULT_HEALTH_CHECK_INTERVAL = 60000; // 1 minute in ms
    private static final int DEFAULT_PROACTIVE_CHECK_INTERVAL = 30000; // 30 seconds in ms
    private int maxPoolSize = DEFAULT_MAX_POOL_SIZE;
    private int maxIdleTime = DEFAULT_MAX_IDLE_TIME;
    private int healthCheckInterval = DEFAULT_HEALTH_CHECK_INTERVAL;

    lock2 = factory2.newReentrantLock(MyOrder.SECOND);
    lock3 = factory2.newReentrantLock(MyOrder.THIRD);

    CycleDetectingLockFactory.WithExplicitOrdering<OtherOrder> factory3 =
        newInstanceWithExplicitOrdering(OtherOrder.class, Policies.THROW);
    lock01 = factory3.newReentrantLock(OtherOrder.FIRST);
    lock02 = factory3.newReentrantLock(OtherOrder.SECOND);
    lock03 = factory3.newReentrantLock(OtherOrder.THIRD);
  }

    lock2 = factory2.newReentrantLock(MyOrder.SECOND);
    lock3 = factory2.newReentrantLock(MyOrder.THIRD);

    CycleDetectingLockFactory.WithExplicitOrdering<OtherOrder> factory3 =
        newInstanceWithExplicitOrdering(OtherOrder.class, Policies.THROW);
    lock01 = factory3.newReentrantLock(OtherOrder.FIRST);
    lock02 = factory3.newReentrantLock(OtherOrder.SECOND);
    lock03 = factory3.newReentrantLock(OtherOrder.THIRD);
  }

		isEqual := func() {
			if curTime, ok := got.(time.Time); ok {
				format := "2006-01-02T15:04:05Z07:00"

				if curTime.Round(time.Second).UTC().Format(format) != expect.(time.Time).Round(time.Second).UTC().Format(format) && curTime.Truncate(time.Second).UTC().Format(format) != expect.(time.Time).Truncate(time.Second).UTC().Format(format) {
					t.Errorf("%v: expect: %v, got %v after time round", utils.FileWithLineNum(), expect.(time.Time), curTime)
				}

		throughputHighestGet := uint64(0)
		throughputHighestPut := uint64(0)
		var throughputHighestResults []SpeedTestResult

		sendResult := func() {
			var result madmin.SpeedTestResult

			durationSecs := opts.duration.Seconds()

			result.GETStats.ThroughputPerSec = throughputHighestGet / uint64(durationSecs)
			result.GETStats.ObjectsPerSec = throughputHighestGet / uint64(opts.objectSize) / uint64(durationSecs)