return this;
    }

    public ProcessArgumentsSpec commandLine(Iterable<?> args) {
        List<Object> argsList = Lists.newArrayList(args);
        hasExecutable.setExecutable(argsList.get(0));
        setArgs(argsList.subList(1, argsList.size()));
        return this;
    }

    public List<String> getAllArguments() {
        List<String> allArgs;
        List<String> args = getArgs();

			c, err := ListenPacket(tt.network, tt.address)
			if err != nil {
				continue
			}
			c.Close()
			priv.argLists = append(priv.argLists, tt.args)
		}
		if len(priv.argLists) > 0 {
			tests = append(tests, priv)
		}
	}

	for _, tt := range tests {
		for _, args := range tt.argLists {
			_, err := Dial(args[0], args[1])
			if tt.shouldFail != (err != nil) {

        tg.enumerate(tgList);

        boolean seen = false;

        for (ThreadGroup aTgList : tgList) {
            if (!aTgList.getName().equals(DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME)) {
                continue;
            }

            seen = true;

            tg = aTgList;
            Thread[] ts = new Thread[tg.activeCount()];
            tg.enumerate(ts);

        final List<EsAccessResult> arList = ((EsDataService) dataService).getAccessResultList(cb);
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (!arList.isEmpty()) {
            final long commitMarginTime = fessConfig.getIndexerWebfsCommitMarginTimeAsInteger().longValue();
            for (final AccessResult<?> ar : arList.toArray(new AccessResult[arList.size()])) {

	var usecases = []struct {
		name      string
		runner    Runner
		testCases map[string]argTest
		cmd       *cobra.Command
	}{
		{
			name: "leaf command, no defined args, follow parent",
			runner: Runner{
				Phases: []Phase{phaseBuilder("foo")},
			},
			testCases: map[string]argTest{
				"phase foo": {
					pass: []string{"one", "two", "three"},
					fail: []string{"one", "two"},

	{'o', sharpNumFlag, argInt | argPointer},
	{'O', sharpNumFlag, argInt | argPointer},
	{'p', "-#", argPointer},
	{'q', " -+.0#", argRune | argInt | argString},
	{'s', " -+.0", argString},
	{'t', "-", argBool},
	{'T', "-", anyType},
	{'U', "-#", argRune | argInt},
	{'v', allFlags, anyType},
	{'w', allFlags, argError},
	{'x', sharpNumFlag, argRune | argInt | argString | argPointer | argFloat | argComplex},

		case types.UntypedString,
			types.String:
			return m.t&argString != 0

		case types.UnsafePointer:
			return m.t&(argPointer|argInt) != 0

		case types.UntypedRune:
			return m.t&(argInt|argRune) != 0

		case types.UntypedNil:
			return false

		case types.Invalid:
			return true // Probably a type check problem.
		}
		panic("unreachable")
	}

	return false
}

	case sqlFnDateDiff:
		return handleDateDiff(r, e.DateDiff, tableAlias)

	}

	// For all simple argument functions, we evaluate the arguments here
	argVals := make([]*Value, len(e.SFunc.ArgsList))
	for i, arg := range e.SFunc.ArgsList {
		argVals[i], err = arg.evalNode(r, tableAlias)
		if err != nil {
			return nil, err
		}
	}

	switch e.getFunctionName() {
	case sqlFnCoalesce:
		return coalesce(argVals)

      auto arg_it = info.stack_var_arg_to_size_arg.find(i);
      if (arg_it == info.stack_var_arg_to_size_arg.end()) continue;
      auto it = data_var_to_size_var.find(call.getOperand(i));
      if (it == data_var_to_size_var.end()) {
        call.emitOpError("unknown stack");
        return failure();
      }
      assert(arg_it->second == new_operands.size());

	// LDNP <St>, <St2>, [<Xn|SP>{, #<imm_2>}]
	{0xffc00000, 0x2c400000, LDNP, instArgs{arg_St, arg_St2, arg_Xns_mem_optional_imm7_4_signed}, nil},
	// LDNP <Dt>, <Dt2>, [<Xn|SP>{, #<imm>}]
	{0xffc00000, 0x6c400000, LDNP, instArgs{arg_Dt, arg_Dt2, arg_Xns_mem_optional_imm7_8_signed}, nil},