m.IngressClass = "foo"
	writeMessage(t, path, m)

	select {
	case <-doneCh:
		assert.Equal(t, newM, m)
		assert.Equal(t, w.Mesh(), newM)
		break
	case <-time.After(time.Second * 5):
		t.Fatal("timed out waiting for update")
	}
}

func newWatcher(t testing.TB, filename string, multi bool) mesh.Watcher {
	t.Helper()
	w, err := mesh.NewFileWatcher(filewatcher.NewWatcher(), filename, multi)
	if err != nil {

	SYSCALL
	RET

TEXT runtime·timer_create(SB),NOSPLIT,$0-28
	MOVL	clockid+0(FP), DI
	MOVQ	sevp+8(FP), SI
	MOVQ	timerid+16(FP), DX
	MOVL	$SYS_timer_create, AX
	SYSCALL
	MOVL	AX, ret+24(FP)
	RET

TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
	MOVL	timerid+0(FP), DI
	MOVL	flags+4(FP), SI
	MOVQ	new+8(FP), DX
	MOVQ	old+16(FP), R10
	MOVL	$SYS_timer_settime, AX
	SYSCALL

			}
			// This call can have different handlers, but the default chain rate limits. Call it after the metrics are updated
			// in case the rate limit delays it.  If you outrun the rate for this one timed out requests, something has gone
			// seriously wrong with your server, but generally having a logging signal for timeouts is useful.

        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:"
}

TEXT runtime·timer_create(SB),NOSPLIT,$0-16
	MOVL	$SYS_timer_create, AX
	MOVL	clockid+0(FP), BX
	MOVL	sevp+4(FP), CX
	MOVL	timerid+8(FP), DX
	INVOKE_SYSCALL
	MOVL	AX, ret+12(FP)
	RET

TEXT runtime·timer_settime(SB),NOSPLIT,$0-20
	MOVL	$SYS_timer_settime, AX
	MOVL	timerid+0(FP), BX
	MOVL	flags+4(FP), CX
	MOVL	new+8(FP), DX
	MOVL	old+12(FP), SI
	INVOKE_SYSCALL
	MOVL	AX, ret+16(FP)
	RET

      ListeningExecutorService executorService,
      Collection<? extends Callable<T>> tasks,
      boolean timed,
      Duration timeout)
      throws InterruptedException, ExecutionException, TimeoutException {
    return invokeAnyImpl(
        executorService, tasks, timed, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

  /**

				if plugin.SocketPath == socketPath && plugin.Timestamp.After(previousTimestamp) {
					return true, nil
				}
			}
			return false, nil
		},
	)
	if err != nil {
		t.Fatalf("Timed out waiting for plugin to be registered:\n%s.", socketPath)
	}
}

func waitForUnregistration(
	t *testing.T,
	socketPath string,
	asw cache.ActualStateOfWorld) {
	err := retryWithExponentialBackOff(

			n := runtime.Stack(buf, true)
			t.Fatalf("timed out after %v waiting for <-ctx.Done(); stacks:\n%s", d, buf[:n])
		}
	}
	// Wait for all the cancel functions to return.
	done := make(chan struct{})
	go func() {
		wg.Wait()
		close(done)
	}()
	select {
	case <-done:
	case <-stuck:
		buf := make([]byte, 10<<10)
		n := runtime.Stack(buf, true)

	MOVD	sevp+8(FP), R4
	MOVD	timerid+16(FP), R5
	SYSCALL	$SYS_timer_create
	MOVW	R3, ret+24(FP)
	RET

TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
	MOVW	timerid+0(FP), R3
	MOVW	flags+4(FP), R4
	MOVD	new+8(FP), R5
	MOVD	old+16(FP), R6
	SYSCALL	$SYS_timer_settime
	MOVW	R3, ret+24(FP)
	RET

TEXT runtime·timer_delete(SB),NOSPLIT,$0-12
	MOVW	timerid+0(FP), R3
	SYSCALL	$SYS_timer_delete

  //     }

  public static long SHORT_DELAY_MS;
  public static long SMALL_DELAY_MS;
  public static long MEDIUM_DELAY_MS;
  public static long LONG_DELAY_MS;

  /**
   * Returns the shortest timed delay. This could be reimplemented to use for example a Property.
   */
  protected long getShortDelay() {
    return 50;
  }

  /** Sets delays as multiples of SHORT_DELAY. */
  protected void setDelays() {