def operand29 = moduleId('quicksand', 'eyes')
        def operand30 = moduleId('crib', 'thumb')
        def operand31 = module('church')
        def operand32 = moduleId('needle', 'celery')
        def operand33 = moduleId('crib', 'competition')
        def operand34 = moduleId('metal', 'box')
        def operand35 = moduleId('root', 'industry')
        def operand36 = group('brother')

		if cpu.gcDedicated <= 0 && cpu.gcAssist <= 0 && cpu.gcIdle <= 0 {
			t.Errorf("found no time spent on GC work: %#v", cpu)
		}
		if cpu.gcPause <= 0 {
			t.Errorf("found no GC pauses: %f", cpu.gcPause)
		}
		if cpu.idle <= 0 {
			t.Errorf("found no idle time: %f", cpu.idle)
		}
		if total := cpu.gcDedicated + cpu.gcAssist + cpu.gcIdle + cpu.gcPause; !withinEpsilon(cpu.gcTotal, total, 0.001) {

  // CHECK-SAME: f = @add
  // CHECK-SAME: device = "noodle"
  %4 = "tf.Case"(%2, %arg0, %arg1) {branches = [@sub, @add], output_shapes = [#tf_type.shape<>], device = "noodle", is_stateless = false} : (tensor<i32>, tensor<f32>, tensor<f32>) -> tensor<f32>
  // CHECK: PartitionedCall
  // CHECK-SAME: f = @sub
  // CHECK-SAME: _cluster_launch = "not_ready"
  // CHECK-SAME: device = "noodle"

	cases := []struct {
		name        string
		idleTimeout string
		expected    *durationpb.Duration
	}{
		{
			"no idle timeout",
			"",
			nil,
		},
		{
			"invalid timeout",
			"invalid-30s",
			nil,
		},
		{
			"valid idle timeout 30s",
			"30s",
			durationpb.New(30 * time.Second),
		},
	}

	services := []*model.Service{

	GCIdleTime      int64 // GC idle mark workers
	GCPauseTime     int64 // GC pauses (all GOMAXPROCS, even if just 1 is running)
	GCTotalTime     int64

	ScavengeAssistTime int64 // background scavenger
	ScavengeBgTime     int64 // scavenge assists
	ScavengeTotalTime  int64

	IdleTime int64 // Time Ps spent in _Pidle.

	if qs == nil {
		qs = &ctlrTestQueueSet{cts: cqc.cts, qc: cqc.qc, dc: dc}
		cqc.cts.queues[cqc.qc.Name] = qs
	} else {
		qs.qc, qs.dc = cqc.qc, dc
	}
	return qs
}

func (cqs *ctlrTestQueueSet) IsIdle() bool {
	cqs.cts.lock.Lock()
	defer cqs.cts.lock.Unlock()
	klog.V(7).Infof("For %p QS %s, countActive==%d", cqs, cqs.qc.Name, cqs.countActive)
	return cqs.countActive == 0
}

          return -1L
        }
      },
      delayNanos,
    )
  }

  /** Returns a latch that reaches 0 when the queue is next idle. */
  fun idleLatch(): CountDownLatch {
    taskRunner.lock.withLock {
      // If the queue is already idle, that's easy.
      if (activeTask == null && futureTasks.isEmpty()) {
        return CountDownLatch(0)
      }

	fs.StringVar(&c.ImageServiceEndpoint, "image-service-endpoint", c.ImageServiceEndpoint, "The endpoint of container image service. If not specified, it will be the same with --container-runtime-endpoint by default. Unix Domain Socket are supported on Linux, while npipe and tcp endpoints are supported on Windows. Examples...

        }
        if (lastRegistryState == state && lastLogState == state) {
            return
        }
        // TODO remove debug log
        if (lastRegistryState == State.Stopped && lastLogState == State.Idle) {
            println("The daemon probably disappeared before it could've printed the stop message. Daemon log content:")
            println(logFile.text)
        }

        requireIsolatedTestKitDir = true
    }

    @Rule
    final ConcurrentTestUtil concurrent = new ConcurrentTestUtil(60000)

    def "daemon process dedicated to test execution uses short idle timeout"() {
        when:
        runner().build()

        then:
        testKitDaemons().daemon.context.idleTimeout == 120000
    }