l.log(ctx, LevelInfo, msg, args...)
}

// Warn logs at [LevelWarn].
func (l *Logger) Warn(msg string, args ...any) {
	l.log(context.Background(), LevelWarn, msg, args...)
}

// WarnContext logs at [LevelWarn] with the given context.
func (l *Logger) WarnContext(ctx context.Context, msg string, args ...any) {
	l.log(ctx, LevelWarn, msg, args...)
}

// Error logs at [LevelError].

			args: args{
				namespace: unlabelledNamespace,
				pod:       unlabelledPod,
			},
			want: false,
		},
		{
			name: "pod has sidecar and namespace has ambient enabled",
			args: args{
				namespace: namespaceWithAmbientEnabledLabel,
				pod:       podWithSidecar,
			},
			want: false,
		},
		{
			name: "pod has label to disable ambient redirection",
			args: args{

		"string int string int",
		"~string int ~string int",
		"myInt int myInt int",
		"~string ~int ~string ~int",
		"myInt ~int ~int ∅",
	} {
		args := split(test, 4)
		x := testTerm(args[0])
		y := testTerm(args[1])
		want1 := testTerm(args[2])
		want2 := testTerm(args[3])
		if got1, got2 := x.union(y); !got1.equal(want1) || !got2.equal(want2) {
			t.Errorf("%v.union(%v) = %v, %v; want %v, %v", x, y, got1, got2, want1, want2)

        given:
        def called = []
        Action<?> a = Mock() {
            execute(_) >> { args -> args[0] << 'a' }
        }
        Action<?> b = Mock() {
            execute(_) >> { args -> args[0] << 'b' }
        }
        Action<?> c = Mock() {
            execute(_) >> { args -> args[0] << 'c' }
        }

        when:
        def set = Actions.set(b, a)
        set = Actions.set(set, c)

/**
 */
class CleanArgumentTest {
    @Test
    void cleanArgsShouldRemoveWrongSurroundingQuotes() {
        String[] args = {"\"-Dfoo=bar", "\"-Dfoo2=bar two\""};
        String[] cleanArgs = CleanArgument.cleanArgs(args);
        assertEquals(args.length, cleanArgs.length);
        assertEquals("-Dfoo=bar", cleanArgs[0]);
        assertEquals("-Dfoo2=bar two", cleanArgs[1]);
    }

    @Test

			off += ptr.AuxInt
			ptr = ptr.Args[0]
		} else if ptr.Op == OpAddPtr {
			if idx != nil {
				// We have two or more indexing values.
				// Pick the first one we found.
				return BaseAddress{ptr: ptr, idx: idx}, off
			}
			idx = ptr.Args[1]
			if idx.Op == OpAdd32 || idx.Op == OpAdd64 {
				if idx.Args[0].Op == OpConst32 || idx.Args[0].Op == OpConst64 {
					off += idx.Args[0].AuxInt
					idx = idx.Args[1]

// NewMQTTTarget - creates new MQTT target.
func NewMQTTTarget(id string, args MQTTArgs, loggerOnce logger.LogOnce) (*MQTTTarget, error) {
	if args.MaxReconnectInterval == 0 {
		// Default interval
		// https://github.com/eclipse/paho.mqtt.golang/blob/master/options.go#L115
		args.MaxReconnectInterval = 10 * time.Minute
	}

	if args.KeepAlive == 0 {
		args.KeepAlive = 10 * time.Second
	}

  CreateContext();

  std::vector<XlaCompiler::Argument> args(2);
  args[0].kind = XlaCompiler::Argument::kParameter;
  args[0].initialized = true;
  args[0].type = DT_INT32;
  args[0].shape = TensorShape({1, 2});
  args[1].kind = XlaCompiler::Argument::kParameter;
  args[1].initialized = true;
  args[1].type = DT_INT32;
  args[1].shape = TensorShape({1, 2});

  const XlaCompiler::CompilationResult* result;

        ParameterizedClassDesc[] args = desc.getArguments();
        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));

        desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 1, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));
        args = desc.getArguments();
        assertThat(args.length, is(2));

        spec.systemIncludeRoots >> systemIncludes

        when:
        def args = transformer.transform(spec)

        then:
        assertHasArguments(args, "/I", includes)
        assertHasArguments(args, "/I", systemIncludes)

        and:
        args.indexOf("/I" + includes.last().absoluteFile.toString()) < args.indexOf("/I" + systemIncludes.first().absoluteFile.toString())
    }