* limitations under the License.
 */

package org.gradle.test.fixtures.concurrent

class TestLogger {
    private final long startTime = System.nanoTime()

    void log(def msg) {
        println "* [${(long) ((System.nanoTime() - startTime) / 1000000L)}ms] [${Thread.currentThread().name}] ${msg}"
    }

        for (int i = 0; i < numTasks; i++) {
            tasks.add(testCallable);
        }

        // 時間取得
        final long time = System.nanoTime();

        // Callableタスク(複数)を実行する
        final ExecutorService executor = Executors.newFixedThreadPool(numTasks);
        try {
            final List<Future<Integer>> futures = executor.invokeAll(tasks);

// license that can be found in the LICENSE file.

package runtime

//go:nosplit
func cputicks() int64 {
	// runtime·nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
	return nanotime()

    while (true) {
      val i = responses.iterator()
      while (i.hasNext()) {
        val recordedResponse = i.next()
        if (recordedResponse.request.url.equals(url)) {
          i.remove()
          return recordedResponse
        }
      }
      val nowMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime())
      if (nowMillis >= timeoutMillis) break

        return CLOCK.getCurrentTime();
    }

    /**
     * Measures elapsed time.
     *
     * Timers use System.nanoTime() to measure elapsed time,
     * and are therefore not synchronized with {@link #clock()} or the system wall clock.
     *
     * System.nanoTime() does not consider time elapsed while the system is in hibernation.

	case _AT_PLATFORM:
		cpu.Platform = gostringnocopy((*byte)(unsafe.Pointer(val)))
	}
}

func osArchInit() {}

//go:nosplit
func cputicks() int64 {
	// nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
	return nanotime()

package org.gradle.internal.time

import spock.lang.Specification

import java.util.concurrent.TimeUnit

class DefaultTimerTest extends Specification {

    def timeSource = Mock(TimeSource) {
        1 * nanoTime() >> 0
    }

    def timer = new DefaultTimer(timeSource)

    def testOnlySecondsTwoDigits() throws Exception {
        when:
        setTime(51243)

        then:

        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;
        } else {
          long now = System.nanoTime();
          TimeUnit.NANOSECONDS.timedWait(lock, nanos);
          nanos -= System.nanoTime() - now; // subtract the actual time we waited
        }
      }
    }
  }

  /**

class LoggingEventListener private constructor(
  private val logger: HttpLoggingInterceptor.Logger,
) : EventListener() {
  private var startNs: Long = 0

  override fun callStart(call: Call) {
    startNs = System.nanoTime()

    logWithTime("callStart: ${call.request()}")
  }

  override fun proxySelectStart(
    call: Call,
    url: HttpUrl,
  ) {
    logWithTime("proxySelectStart: $url")
  }

        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;
        } else {
          long now = System.nanoTime();
          TimeUnit.NANOSECONDS.timedWait(lock, nanos);
          nanos -= System.nanoTime() - now; // subtract the actual time we waited
        }
      }
    }
  }

  /**