return time.Time{}, time.Time{}, fmt.Errorf("failed to parse TimeBegin: %v", err)
	}
	timeEnd, ok := parsed.Meta["TimeEnd"]
	if !ok {
		return time.Time{}, time.Time{}, fmt.Errorf("missing counter metadata for TimeEnd")
	}
	end, err = time.Parse(time.RFC3339, timeEnd)
	if err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("failed to parse TimeEnd: %v", err)
	}
	return begin, end, nil
}

		// Timeout
		{probe.Failure, false, true, "", remote.ErrCommandTimedOut.Error() + ": command testcmd timed out", fmt.Errorf("%w: command testcmd timed out", remote.ErrCommandTimedOut)},
		// ExecProbeTimeout
		{probe.Unknown, true, false, "", "", fmt.Errorf("%w: command testcmd timed out", remote.ErrCommandTimedOut)},
	}

	for i, test := range tests {

            appendLine("Resolve extension navigation targets: ${navTargets.size}")
            withIndent { navTargets.forEach { appendLine(it.toString()) } }
        }
    }.trimEnd()

	// trace reader.
	//
	// Events that are not "timed" are considered "structural"
	// since they either need significant reinterpretation or
	// otherwise aren't actually surfaced by the trace reader.
	IsTimedEvent bool

	// HasData is true if the event has trailer consisting of a
	// varint length followed by unencoded bytes of some data.
	//
	// An event may not be both a timed event and have data.
	HasData bool

	updateCRD()

	drained := make(chan struct{})
	go func() {
		defer close(drained)
		wg.Wait()
	}()

	select {
	case <-drained:
	case <-time.After(wait.ForeverTestTimeout):
		t.Fatal("timed out waiting for watchers to be terminated")
	}

	stopChan := make(chan struct{})

	// Set up loop to modify CRD in the background
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			select {

		}

		if errors.Is(err, remote.ErrCommandTimedOut) {
			if utilfeature.DefaultFeatureGate.Enabled(features.ExecProbeTimeout) {
				return probe.Failure, err.Error(), nil
			}

			klog.Warningf("Exec probe timed out but ExecProbeTimeout feature gate was disabled")
		}

		return probe.Unknown, "", err
	}
	return probe.Success, string(data), nil

		svcHandler.lock.Lock()
		defer svcHandler.lock.Unlock()
		if reflect.DeepEqual(svcHandler.state, expectedSvcState) {
			return true, nil
		}
		return false, nil
	})
	if err != nil {
		t.Fatal("Timed out waiting for the completion of handler `OnServiceAdd`")
	}

	err = wait.PollImmediate(time.Millisecond*10, wait.ForeverTestTimeout, func() (bool, error) {
		epsHandler.lock.Lock()
		defer epsHandler.lock.Unlock()

	defer klog.Infof("Shutting down system namespaces controller")

	klog.Infof("Starting system namespaces controller")

	if !cache.WaitForCacheSync(stopCh, c.namespaceSynced) {
		utilruntime.HandleError(fmt.Errorf("timed out waiting for caches to sync"))
		return
	}

	go wait.Until(c.sync, c.interval, stopCh)

	<-stopCh
}

func (c *Controller) sync() {
	// Loop the system namespace list, and create them if they do not exist

//
//	func semasleep(ns int64) int32
//		If ns < 0, acquire m's semaphore and return 0.
//		If ns >= 0, try to acquire m's semaphore for at most ns nanoseconds.
//		Return 0 if the semaphore was acquired, -1 if interrupted or timed out.
//
//	func semawakeup(mp *m)
//		Wake up mp, which is or will soon be sleeping on its semaphore.
const (
	locked uintptr = 1

	active_spin     = 4
	active_spin_cnt = 30
	passive_spin    = 1
)

        val testFileText = FileUtil.loadFile(File(filePath))
        val fileTextWithoutSymbolsData = testFileText.substringBeforeLast(SYMBOLS_TAG).trimEnd()
        appendLine(fileTextWithoutSymbolsData)
        appendLine()
        appendLine(SYMBOLS_TAG)
        append(rendered)
    }

    private const val SYMBOLS_TAG = "// SYMBOLS:"
}