public ExecSpecBackedArgCollector(ExecSpec action) {
        this.action = action;
    }

    @Override
    public ArgCollector args(Object... args) {
        action.args(args);
        return this;
    }

    @Override
    public ArgCollector args(Iterable<?> args) {
        action.args(args);
        return this;
    }

        then:
        1 * asyncConnection.run(!null, !null) >> {args ->
            ConsumerAction<GradleProject> action = args[0]
            action.run(connection)
            adaptedHandler = args[1]
        }
        1 * connection.run(action, _) >> { args ->
            ConsumerOperationParameters params = args[1]
            assert params.tasks == ['a', 'b']
            return result
        }

  },
  {
    name = "examples-bookinfo-productpage-v-flooding"
    args = {
      flood_factor = 100
    }
    source = "productpage"
  },

  // Details
  {
    name = "examples-bookinfo-details-v1"
    args = {
      service_version = "v1"
    }
    source = "details"
  },
  {
    name = "examples-bookinfo-details-v2"
    args = {
      service_version              = "v2"

        """
            tasks.register("run", JavaExec) {
                classpath = project.layout.files(compileJava)
                mainClass = "Main"
                ${formatArgument args["extraArg"], { "args '$it'" }}

                ${formatStreamArgument args, "standardInput"}
                ${formatStreamArgument args, "standardOutput"}
                ${formatStreamArgument args, "errorOutput"}

func rewriteValueAMD64latelower_OpAMD64MOVWQZX(v *Value) bool {
	v_0 := v.Args[0]
	// match: (MOVWQZX x)
	// cond: zeroUpper48Bits(x,3)
	// result: x
	for {
		x := v_0
		if !(zeroUpper48Bits(x, 3)) {
			break
		}
		v.copyOf(x)
		return true
	}
	return false
}
func rewriteValueAMD64latelower_OpAMD64SARL(v *Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (SARL x y)
	// cond: buildcfg.GOAMD64 >= 3

func TestValidateDefaultPreemptionArgs(t *testing.T) {
	cases := map[string]struct {
		args     config.DefaultPreemptionArgs
		wantErrs field.ErrorList
	}{
		"valid args (default)": {
			args: config.DefaultPreemptionArgs{
				MinCandidateNodesPercentage: 10,
				MinCandidateNodesAbsolute:   100,
			},
		},
		"negative minCandidateNodesPercentage": {
			args: config.DefaultPreemptionArgs{
				MinCandidateNodesPercentage: -1,

	}
}

func TestIsValidIPAddress(t *testing.T) {
	type args struct {
		ip string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		{
			name: "test is a valid ipv4 address",
			args: args{
				ip: "10.10.1.1",
			},
			want: true,
		},
		{
			name: "test not a valid ipv4 address",
			args: args{
				ip: "188.188.188.1888",
			},
			want: false,
		},

        then:
        1 * asyncConnection.run(!null, !null) >> { args ->
            ConsumerAction<GradleProject> action = args[0]
            action.run(connection)
            adaptedHandler = args[1]
            adaptedHandler.onComplete(null)
        }
        1 * connection.run(Void, _) >> {args ->
            ConsumerOperationParameters params = args[1]
            assert params.tasks == []

        [String]           | ["abc"]               | "non enum args"
    }

    def "returns original args when no transformation is available for all args - #desc"() {
        def typesArray = types.collect { new CachedClass(it, null) } as CachedClass[]
        def argsArray = args as Object[]

        expect:
        transformer.transform(typesArray, argsArray).is(argsArray)

        where:

			}
			z := v_1.Args[1]
			y := v_1.Args[0]
			flags := v_2
			v.reset(OpARMADCshiftRAreg)
			v.AddArg4(x, y, z, flags)
			return true
		}
		break
	}
	return false
}
func rewriteValueARM_OpARMADCconst(v *Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (ADCconst [c] (ADDconst [d] x) flags)
	// result: (ADCconst [c+d] x flags)
	for {
		c := auxIntToInt32(v.AuxInt)