command_test.go

package cli

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"net/mail"
	"os"
	"slices"
	"sort"
	"strconv"
	"strings"
	"testing"
	"testing/iotest"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

var (
	lastExitCode = 0
	fakeOsExiter = func(rc int) {
		lastExitCode = rc
	}
	fakeErrWriter = &bytes.Buffer{}
)

func init() {
	OsExiter = fakeOsExiter
	ErrWriter = fakeErrWriter
}

type opCounts struct {
	Total, ShellComplete, OnUsageError, Before, CommandNotFound, Action, After, SubCommand int
}

func buildExtendedTestCommand() *Command {
	cmd := buildMinimalTestCommand()
	cmd.Name = "greet"
	cmd.Flags = []Flag{
		&StringFlag{
			Name:      "socket",
			Aliases:   []string{"s"},
			Usage:     "some 'usage' text",
			Value:     "value",
			TakesFile: true,
		},
		&StringFlag{Name: "flag", Aliases: []string{"fl", "f"}},
		&BoolFlag{
			Name:    "another-flag",
			Aliases: []string{"b"},
			Usage:   "another usage text",
			Sources: EnvVars("EXAMPLE_VARIABLE_NAME"),
		},
		&BoolFlag{
			Name:   "hidden-flag",
			Hidden: true,
		},
	}
	cmd.Commands = []*Command{{
		Aliases: []string{"c"},
		Flags: []Flag{
			&StringFlag{
				Name:      "flag",
				Aliases:   []string{"fl", "f"},
				TakesFile: true,
			},
			&BoolFlag{
				Name:    "another-flag",
				Aliases: []string{"b"},
				Usage:   "another usage text",
			},
		},
		Name:  "config",
		Usage: "another usage test",
		Commands: []*Command{{
			Aliases: []string{"s", "ss"},
			Flags: []Flag{
				&StringFlag{Name: "sub-flag", Aliases: []string{"sub-fl", "s"}},
				&BoolFlag{
					Name:    "sub-command-flag",
					Aliases: []string{"s"},
					Usage:   "some usage text",
				},
			},
			Name:  "sub-config",
			Usage: "another usage test",
		}},
	}, {
		Aliases: []string{"i", "in"},
		Name:    "info",
		Usage:   "retrieve generic information",
	}, {
		Name: "some-command",
	}, {
		Name:   "hidden-command",
		Hidden: true,
		Flags: []Flag{
			&BoolFlag{
				Name: "completable",
			},
		},
	}, {
		Aliases: []string{"u"},
		Flags: []Flag{
			&StringFlag{
				Name:      "flag",
				Aliases:   []string{"fl", "f"},
				TakesFile: true,
			},
			&BoolFlag{
				Name:    "another-flag",
				Aliases: []string{"b"},
				Usage:   "another usage text",
			},
		},
		Name:  "usage",
		Usage: "standard usage text",
		UsageText: `
Usage for the usage text
- formatted:  Based on the specified ConfigMap and summon secrets.yml
- list:       Inspect the environment for a specific process running on a Pod
- for_effect: Compare 'namespace' environment with 'local'

` + "```" + `
func() { ... }
` + "```" + `

Should be a part of the same code block
`,
		Commands: []*Command{{
			Aliases: []string{"su"},
			Flags: []Flag{
				&BoolFlag{
					Name:    "sub-command-flag",
					Aliases: []string{"s"},
					Usage:   "some usage text",
				},
			},
			Name:      "sub-usage",
			Usage:     "standard usage text",
			UsageText: "Single line of UsageText",
		}},
	}}
	cmd.UsageText = "app [first_arg] [second_arg]"
	cmd.Description = `Description of the application.`
	cmd.Usage = "Some app"
	cmd.Authors = []any{
		"Harrison <harrison@lolwut.example.com>",
		&mail.Address{Name: "Oliver Allen", Address: "oliver@toyshop.com"},
	}

	return cmd
}

func TestCommandFlagParsing(t *testing.T) {
	cases := []struct {
		testArgs               []string
		skipFlagParsing        bool
		useShortOptionHandling bool
		expectedErr            string
	}{
		// Test normal "not ignoring flags" flow
		{testArgs: []string{"test-cmd", "-break", "blah", "blah"}, skipFlagParsing: false, useShortOptionHandling: false, expectedErr: "flag provided but not defined: -break"},
		{testArgs: []string{"test-cmd", "blah", "blah"}, skipFlagParsing: true, useShortOptionHandling: false},   // Test SkipFlagParsing without any args that look like flags
		{testArgs: []string{"test-cmd", "blah", "-break"}, skipFlagParsing: true, useShortOptionHandling: false}, // Test SkipFlagParsing with random flag arg
		{testArgs: []string{"test-cmd", "blah", "-help"}, skipFlagParsing: true, useShortOptionHandling: false},  // Test SkipFlagParsing with "special" help flag arg
	}

	for _, c := range cases {
		t.Run(strings.Join(c.testArgs, " "), func(t *testing.T) {
			cmd := &Command{
				Writer:          io.Discard,
				Name:            "test-cmd",
				Aliases:         []string{"tc"},
				Usage:           "this is for testing",
				Description:     "testing",
				Action:          func(context.Context, *Command) error { return nil },
				SkipFlagParsing: c.skipFlagParsing,
			}

			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
			t.Cleanup(cancel)

			r := require.New(t)

			err := cmd.Run(ctx, c.testArgs)

			if c.expectedErr != "" {
				r.EqualError(err, c.expectedErr)
			} else {
				r.NoError(err)
			}
		})
	}
}

func TestParseAndRunShortOpts(t *testing.T) {
	testCases := []struct {
		testArgs     *stringSliceArgs
		expectedErr  string
		expectedArgs Args
	}{
		{testArgs: &stringSliceArgs{v: []string{"test", "-a"}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-c", "arg1", "arg2"}}, expectedArgs: &stringSliceArgs{v: []string{"arg1", "arg2"}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-f"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-ac", "--fgh"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-af"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-cf"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acf"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "--acf"}}, expectedErr: "flag provided but not defined: -acf"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acf", "-invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "--invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acf", "--invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acf", "arg1", "-invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acf", "arg1", "--invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-acfi", "not-arg", "arg1", "-invalid"}}, expectedErr: "flag provided but not defined: -invalid"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-i", "ivalue"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-i", "ivalue", "arg1"}}, expectedArgs: &stringSliceArgs{v: []string{"arg1"}}},
		{testArgs: &stringSliceArgs{v: []string{"test", "-i"}}, expectedErr: "flag needs an argument: -i"},
		// a flag that takes a value has to be the last one of a group
		{testArgs: &stringSliceArgs{v: []string{"test", "-ia"}}, expectedErr: "flag needs an argument: i"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-ia", "ivalue"}}, expectedErr: "flag needs an argument: i"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-aic"}}, expectedErr: "flag needs an argument: i"},
		{testArgs: &stringSliceArgs{v: []string{"test", "-ai", "ivalue"}}, expectedArgs: &stringSliceArgs{v: []string{}}},
	}

	for _, tc := range testCases {
		t.Run(strings.Join(tc.testArgs.v, " "), func(t *testing.T) {
			state := map[string]Args{"args": nil}

			cmd := &Command{
				Name:        "test",
				Usage:       "this is for testing",
				Description: "testing",
				Action: func(_ context.Context, cmd *Command) error {
					state["args"] = cmd.Args()
					return nil
				},
				UseShortOptionHandling: true,
				Writer:                 io.Discard,
				Flags: []Flag{
					&BoolFlag{Name: "abc", Aliases: []string{"a"}},
					&BoolFlag{Name: "cde", Aliases: []string{"c"}},
					&BoolFlag{Name: "fgh", Aliases: []string{"f"}},
					&StringFlag{Name: "ijk", Aliases: []string{"i"}},
				},
			}

			err := cmd.Run(buildTestContext(t), tc.testArgs.Slice())

			r := require.New(t)

			if tc.expectedErr == "" {
				r.NoError(err)
			} else {
				r.ErrorContains(err, tc.expectedErr)
			}

			if tc.expectedArgs == nil {
				if state["args"] != nil {
					r.Len(state["args"].Slice(), 0)
				} else {
					r.Nil(state["args"])
				}
			} else {
				r.Equal(tc.expectedArgs, state["args"])
			}
		})
	}
}

func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
	cmd := &Command{
		Name: "bar",
		Before: func(context.Context, *Command) (context.Context, error) {
			return nil, fmt.Errorf("before error")
		},
		After: func(context.Context, *Command) error {
			return fmt.Errorf("after error")
		},
		Writer: io.Discard,
	}

	err := cmd.Run(buildTestContext(t), []string{"bar"})

	require.ErrorContains(t, err, "before error")
	require.ErrorContains(t, err, "after error")
}

func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
	var receivedMsgFromAction string
	var receivedMsgFromAfter string

	cmd := &Command{
		Name: "bar",
		Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
			cmd.Metadata["msg"] = "hello world"
			return nil, nil
		},
		Action: func(ctx context.Context, cmd *Command) error {
			msg, ok := cmd.Metadata["msg"]
			if !ok {
				return errors.New("msg not found")
			}
			receivedMsgFromAction = msg.(string)

			return nil
		},
		After: func(_ context.Context, cmd *Command) error {
			msg, ok := cmd.Metadata["msg"]
			if !ok {
				return errors.New("msg not found")
			}
			receivedMsgFromAfter = msg.(string)
			return nil
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"foo", "bar"}))
	require.Equal(t, "hello world", receivedMsgFromAction)
	require.Equal(t, "hello world", receivedMsgFromAfter)
}

func TestCommand_Run_BeforeReturnNewContext(t *testing.T) {
	var receivedValFromAction, receivedValFromAfter string
	type key string

	bkey := key("bkey")

	cmd := &Command{
		Name: "bar",
		Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
			return context.WithValue(ctx, bkey, "bval"), nil
		},
		Action: func(ctx context.Context, cmd *Command) error {
			if val := ctx.Value(bkey); val == nil {
				return errors.New("bkey value not found")
			} else {
				receivedValFromAction = val.(string)
			}
			return nil
		},
		After: func(ctx context.Context, cmd *Command) error {
			if val := ctx.Value(bkey); val == nil {
				return errors.New("bkey value not found")
			} else {
				receivedValFromAfter = val.(string)
			}
			return nil
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"foo", "bar"}))
	require.Equal(t, "bval", receivedValFromAfter)
	require.Equal(t, "bval", receivedValFromAction)
}

type ctxKey string

// ctxCollector is a small helper to collect context values.
type ctxCollector struct {
	// keys are the keys to check the context for.
	keys []ctxKey

	// m maps from function name to context name to value.
	m map[string]map[ctxKey]string
}

func (cc *ctxCollector) collect(ctx context.Context, fnName string) {
	if cc.m == nil {
		cc.m = make(map[string]map[ctxKey]string)
	}

	if _, ok := cc.m[fnName]; !ok {
		cc.m[fnName] = make(map[ctxKey]string)
	}

	for _, k := range cc.keys {
		if val := ctx.Value(k); val != nil {
			cc.m[fnName][k] = val.(string)
		}
	}
}

func TestCommand_Run_BeforeReturnNewContextSubcommand(t *testing.T) {
	bkey := ctxKey("bkey")
	bkey2 := ctxKey("bkey2")

	cc := &ctxCollector{keys: []ctxKey{bkey, bkey2}}
	cmd := &Command{
		Name: "bar",
		Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
			return context.WithValue(ctx, bkey, "bval"), nil
		},
		After: func(ctx context.Context, cmd *Command) error {
			cc.collect(ctx, "bar.After")
			return nil
		},
		Commands: []*Command{
			{
				Name: "baz",
				Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
					return context.WithValue(ctx, bkey2, "bval2"), nil
				},
				Action: func(ctx context.Context, cmd *Command) error {
					cc.collect(ctx, "baz.Action")
					return nil
				},
				After: func(ctx context.Context, cmd *Command) error {
					cc.collect(ctx, "baz.After")
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"bar", "baz"}))
	expected := map[string]map[ctxKey]string{
		"bar.After": {
			bkey:  "bval",
			bkey2: "bval2",
		},
		"baz.Action": {
			bkey:  "bval",
			bkey2: "bval2",
		},
		"baz.After": {
			bkey:  "bval",
			bkey2: "bval2",
		},
	}
	require.Equal(t, expected, cc.m)
}

func TestCommand_Run_FlagActionContext(t *testing.T) {
	bkey := ctxKey("bkey")
	bkey2 := ctxKey("bkey2")

	cc := &ctxCollector{keys: []ctxKey{bkey, bkey2}}
	cmd := &Command{
		Name: "bar",
		Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
			return context.WithValue(ctx, bkey, "bval"), nil
		},
		Flags: []Flag{
			&StringFlag{
				Name: "foo",
				Action: func(ctx context.Context, cmd *Command, _ string) error {
					cc.collect(ctx, "bar.foo.Action")
					return nil
				},
			},
		},
		Commands: []*Command{
			{
				Name: "baz",
				Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
					return context.WithValue(ctx, bkey2, "bval2"), nil
				},
				Flags: []Flag{
					&StringFlag{
						Name: "goo",
						Action: func(ctx context.Context, cmd *Command, _ string) error {
							cc.collect(ctx, "baz.goo.Action")
							return nil
						},
					},
				},
				Action: func(ctx context.Context, cmd *Command) error {
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"bar", "--foo", "value", "baz", "--goo", "value"}))
	expected := map[string]map[ctxKey]string{
		"bar.foo.Action": {
			bkey:  "bval",
			bkey2: "bval2",
		},
		"baz.goo.Action": {
			bkey:  "bval",
			bkey2: "bval2",
		},
	}
	require.Equal(t, expected, cc.m)
}

func TestCommand_OnUsageError_hasCommandContext(t *testing.T) {
	cmd := &Command{
		Name: "bar",
		Flags: []Flag{
			&Int64Flag{Name: "flag"},
		},
		OnUsageError: func(_ context.Context, cmd *Command, err error, _ bool) error {
			return fmt.Errorf("intercepted in %s: %s", cmd.Name, err.Error())
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"bar", "--flag=wrong"})
	assert.ErrorContains(t, err, "intercepted in bar")
}

func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
	cmd := &Command{
		Name: "bar",
		Flags: []Flag{
			&Int64Flag{Name: "flag"},
		},
		OnUsageError: func(_ context.Context, _ *Command, err error, _ bool) error {
			assert.ErrorContains(t, err, "strconv.ParseInt: parsing \"wrong\"")
			return errors.New("intercepted: " + err.Error())
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"bar", "--flag=wrong"})
	assert.ErrorContains(t, err, "intercepted: invalid value \"wrong\" for flag -flag: strconv.ParseInt: parsing \"wrong\"")
}

func TestCommand_OnUsageError_WithSubcommand(t *testing.T) {
	cmd := &Command{
		Name: "bar",
		Commands: []*Command{
			{
				Name: "baz",
			},
		},
		Flags: []Flag{
			&Int64Flag{Name: "flag"},
		},
		OnUsageError: func(_ context.Context, _ *Command, err error, _ bool) error {
			assert.ErrorContains(t, err, "parsing \"wrong\": invalid syntax")
			return errors.New("intercepted: " + err.Error())
		},
	}

	require.ErrorContains(t, cmd.Run(buildTestContext(t), []string{"bar", "--flag=wrong"}),
		"intercepted: invalid value \"wrong\" for flag -flag: strconv.ParseInt: parsing \"wrong\": invalid syntax")
}

func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) {
	cmd := &Command{
		ErrWriter: io.Discard,
		Name:      "bar",
		Usage:     "this is for testing",
		Commands: []*Command{
			{
				Name:  "baz",
				Usage: "this is for testing",
				Action: func(_ context.Context, cmd *Command) error {
					require.Equal(t, io.Discard, cmd.Root().ErrWriter)

					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"bar", "baz"}))
}

func TestCommandSkipFlagParsing(t *testing.T) {
	cases := []struct {
		testArgs     *stringSliceArgs
		expectedArgs *stringSliceArgs
		expectedErr  error
	}{
		{testArgs: &stringSliceArgs{v: []string{"some-command", "some-arg", "--flag", "foo"}}, expectedArgs: &stringSliceArgs{v: []string{"some-arg", "--flag", "foo"}}, expectedErr: nil},
		{testArgs: &stringSliceArgs{v: []string{"some-command", "some-arg", "--flag=foo"}}, expectedArgs: &stringSliceArgs{v: []string{"some-arg", "--flag=foo"}}, expectedErr: nil},
	}

	for _, c := range cases {
		t.Run(strings.Join(c.testArgs.Slice(), " "), func(t *testing.T) {
			var args Args
			cmd := &Command{
				SkipFlagParsing: true,
				Name:            "some-command",
				Flags: []Flag{
					&StringFlag{Name: "flag"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					args = cmd.Args()
					return nil
				},
				Writer: io.Discard,
			}

			err := cmd.Run(buildTestContext(t), c.testArgs.Slice())
			assert.Equal(t, c.expectedErr, err)
			assert.Equal(t, c.expectedArgs, args)
		})
	}
}

func TestCommand_Run_CustomShellCompleteAcceptsMalformedFlags(t *testing.T) {
	cases := []struct {
		testArgs    *stringSliceArgs
		expectedOut string
	}{
		{testArgs: &stringSliceArgs{v: []string{"--undefined"}}, expectedOut: "found 1 args"},
		{testArgs: &stringSliceArgs{v: []string{"--number"}}, expectedOut: "found 1 args"},
		{testArgs: &stringSliceArgs{v: []string{"--number", "forty-two"}}, expectedOut: "found 0 args"},
		{testArgs: &stringSliceArgs{v: []string{"--number", "42"}}, expectedOut: "found 0 args"},
		{testArgs: &stringSliceArgs{v: []string{"--number", "42", "newArg"}}, expectedOut: "found 1 args"},
	}

	for _, c := range cases {
		t.Run(strings.Join(c.testArgs.Slice(), " "), func(t *testing.T) {
			out := &bytes.Buffer{}
			cmd := &Command{
				Writer:                out,
				EnableShellCompletion: true,
				Name:                  "bar",
				Usage:                 "this is for testing",
				Flags: []Flag{
					&Int64Flag{
						Name:  "number",
						Usage: "A number to parse",
					},
				},
				ShellComplete: func(_ context.Context, cmd *Command) {
					fmt.Fprintf(cmd.Root().Writer, "found %[1]d args", cmd.NArg())
				},
			}

			osArgs := &stringSliceArgs{v: []string{"bar"}}
			osArgs.v = append(osArgs.v, c.testArgs.Slice()...)
			osArgs.v = append(osArgs.v, completionFlag)

			r := require.New(t)

			r.NoError(cmd.Run(buildTestContext(t), osArgs.Slice()))
			r.Equal(c.expectedOut, out.String())
		})
	}
}

func TestCommand_CanAddVFlagOnSubCommands(t *testing.T) {
	cmd := &Command{
		Version: "some version",
		Writer:  io.Discard,
		Name:    "foo",
		Usage:   "this is for testing",
		Commands: []*Command{
			{
				Name: "bar",
				Flags: []Flag{
					&BoolFlag{Name: "v"},
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "bar"})
	assert.NoError(t, err)
}

func TestCommand_VisibleSubcCommands(t *testing.T) {
	subc1 := &Command{
		Name:  "subc1",
		Usage: "subc1 command1",
	}
	subc3 := &Command{
		Name:  "subc3",
		Usage: "subc3 command2",
	}
	cmd := &Command{
		Name:  "bar",
		Usage: "this is for testing",
		Commands: []*Command{
			subc1,
			{
				Name:   "subc2",
				Usage:  "subc2 command2",
				Hidden: true,
			},
			subc3,
		},
	}

	assert.Equal(t, cmd.VisibleCommands(), []*Command{subc1, subc3})
}

func TestCommand_VisibleFlagCategories(t *testing.T) {
	cmd := &Command{
		Name:  "bar",
		Usage: "this is for testing",
		Flags: []Flag{
			&StringFlag{
				Name: "strd", // no category set
			},
			&StringFlag{
				Name:   "strd1", // no category set and also hidden
				Hidden: true,
			},
			&Int64Flag{
				Name:     "intd",
				Aliases:  []string{"altd1", "altd2"},
				Category: "cat1",
			},
			&StringFlag{
				Name:     "sfd",
				Category: "cat2", // category set and hidden
				Hidden:   true,
			},
		},
		MutuallyExclusiveFlags: []MutuallyExclusiveFlags{{
			Category: "cat2",
			Flags: [][]Flag{
				{
					&StringFlag{
						Name: "mutex",
					},
				},
			},
		}},
	}

	cmd.MutuallyExclusiveFlags[0].propagateCategory()

	vfc := cmd.VisibleFlagCategories()
	require.Len(t, vfc, 3)

	assert.Equal(t, vfc[0].Name(), "", "expected category name to be empty")
	assert.Equal(t, vfc[0].Flags()[0].Names(), []string{"strd"})

	assert.Equal(t, vfc[1].Name(), "cat1", "expected category name cat1")
	require.Len(t, vfc[1].Flags(), 1, "expected flag category to have one flag")
	assert.Equal(t, vfc[1].Flags()[0].Names(), []string{"intd", "altd1", "altd2"})

	assert.Equal(t, vfc[2].Name(), "cat2", "expected category name cat2")
	require.Len(t, vfc[2].Flags(), 1, "expected flag category to have one flag")
	assert.Equal(t, vfc[2].Flags()[0].Names(), []string{"mutex"})
}

func TestCommand_RunSubcommandWithDefault(t *testing.T) {
	cmd := &Command{
		Version:        "some version",
		Name:           "app",
		DefaultCommand: "foo",
		Commands: []*Command{
			{
				Name: "foo",
				Action: func(context.Context, *Command) error {
					return errors.New("should not run this subcommand")
				},
			},
			{
				Name:     "bar",
				Usage:    "this is for testing",
				Commands: []*Command{{}}, // some subcommand
				Action: func(context.Context, *Command) error {
					return nil
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"app", "bar"})
	assert.NoError(t, err)

	err = cmd.Run(buildTestContext(t), []string{"app"})
	assert.EqualError(t, err, "should not run this subcommand")
}

func TestCommand_Run(t *testing.T) {
	s := ""

	cmd := &Command{
		Action: func(_ context.Context, cmd *Command) error {
			s = s + cmd.Args().First()
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"command", "foo"})
	assert.NoError(t, err)
	err = cmd.Run(buildTestContext(t), []string{"command", "bar"})
	assert.NoError(t, err)
	assert.Equal(t, s, "foobar")
}

var commandTests = []struct {
	name     string
	expected bool
}{
	{"foobar", true},
	{"batbaz", true},
	{"b", true},
	{"f", true},
	{"bat", false},
	{"nothing", false},
}

func TestCommand_Command(t *testing.T) {
	cmd := &Command{
		Commands: []*Command{
			{Name: "foobar", Aliases: []string{"f"}},
			{Name: "batbaz", Aliases: []string{"b"}},
		},
	}

	for _, test := range commandTests {
		if test.expected {
			assert.NotEmpty(t, cmd.Command(test.name))
		} else {
			assert.Empty(t, cmd.Command(test.name))
		}
	}
}

var defaultCommandTests = []struct {
	cmdName        string
	defaultCmd     string
	args           []string
	errNotExpected bool
}{
	{"foobar", "foobar", nil, true},
	{"batbaz", "foobar", nil, true},
	{"b", "", nil, true},
	{"f", "", nil, true},
	{"", "foobar", nil, true},
	{"", "", nil, true},
	{" ", "", nil, false},
	{"bat", "batbaz", nil, true},
	{"nothing", "batbaz", nil, true},
	{"nothing", "", nil, false},
	{"foobar", "foobar", []string{"xy", "zdf"}, true},
	{"", "foobar", []string{"xy", "zdf"}, true},
}

func TestCommand_RunDefaultCommand(t *testing.T) {
	for _, test := range defaultCommandTests {
		testTitle := fmt.Sprintf("command=%[1]s-default=%[2]s-args=%[3]v", test.cmdName, test.defaultCmd, test.args)
		t.Run(testTitle, func(t *testing.T) {
			fooCount := 0
			var fooArgs Args
			barCount := 0
			cmd := &Command{
				DefaultCommand: test.defaultCmd,
				Commands: []*Command{
					{
						Name:    "foobar",
						Aliases: []string{"f"},
						Action: func(ctx context.Context, c *Command) error {
							fooCount++
							fooArgs = c.Args()
							return nil
						},
					},
					{
						Name:    "batbaz",
						Aliases: []string{"b"},
						Action: func(ctx context.Context, c *Command) error {
							barCount++
							return nil
						},
					},
				},
			}

			runArgs := []string{"c"}
			if test.cmdName != "" {
				runArgs = append(runArgs, test.cmdName)
			}
			if test.args != nil {
				runArgs = append(runArgs, test.args...)
			}
			err := cmd.Run(buildTestContext(t), runArgs)
			if test.errNotExpected {
				assert.NoError(t, err)
				if fooCount == 0 && barCount == 0 && test.defaultCmd != "" {
					t.Errorf("expected one of the commands to run")
				}
				if fooCount > 0 {
					expectedArgs := &stringSliceArgs{v: []string{}}
					if len(test.args) > 0 && (test.args[0] == "foobar" || test.args[0] == "f") {
						expectedArgs = &stringSliceArgs{v: test.args[1:]}
					} else if test.args != nil {
						expectedArgs = &stringSliceArgs{v: test.args}
					}
					assert.Equal(t, expectedArgs, fooArgs)
				}
			} else {
				if fooCount > 0 || barCount > 0 {
					t.Errorf("expected no commands to run")
				}
				assert.Error(t, err)
			}
		})
	}
}

var defaultCommandSubCommandTests = []struct {
	cmdName        string
	subCmd         string
	defaultCmd     string
	errNotExpected bool
}{
	{"foobar", "", "foobar", true},
	{"foobar", "carly", "foobar", true},
	{"batbaz", "", "foobar", true},
	{"b", "", "", true},
	{"f", "", "", true},
	{"", "", "foobar", true},
	{"", "", "", true},
	{"", "jimbob", "foobar", true},
	{"", "j", "foobar", true},
	{"", "carly", "foobar", true},
	{"", "jimmers", "foobar", false},
	{"", "jimmers", "", false},
	{" ", "jimmers", "foobar", false},
	{"", "", "", true},
	{" ", "", "", false},
	{" ", "j", "", false},
	{"bat", "", "batbaz", false},
	{"nothing", "", "batbaz", false},
	{"nothing", "", "", false},
	{"nothing", "j", "batbaz", false},
	{"nothing", "carly", "", false},
}

func TestCommand_RunDefaultCommandWithSubCommand(t *testing.T) {
	for _, test := range defaultCommandSubCommandTests {
		testTitle := fmt.Sprintf("command=%[1]s-subcmd=%[2]s-default=%[3]s", test.cmdName, test.subCmd, test.defaultCmd)
		t.Run(testTitle, func(t *testing.T) {
			cmd := &Command{
				DefaultCommand: test.defaultCmd,
				Commands: []*Command{
					{
						Name:    "foobar",
						Aliases: []string{"f"},
						Commands: []*Command{
							{Name: "jimbob", Aliases: []string{"j"}},
							{Name: "carly"},
						},
					},
					{Name: "batbaz", Aliases: []string{"b"}},
				},
			}

			runArgs := []string{"c"}
			if test.cmdName != "" {
				runArgs = append(runArgs, test.cmdName)
			}
			if test.subCmd != "" {
				runArgs = append(runArgs, test.subCmd)
			}
			err := cmd.Run(buildTestContext(t), runArgs)
			if test.errNotExpected {
				assert.NoError(t, err)
			} else {
				assert.Error(t, err)
			}
		})
	}
}

var defaultCommandFlagTests = []struct {
	cmdName        string
	flag           string
	defaultCmd     string
	errNotExpected bool
}{
	{"foobar", "", "foobar", true},
	{"foobar", "-c derp", "foobar", true},
	{"batbaz", "", "foobar", true},
	{"b", "", "", true},
	{"f", "", "", true},
	{"", "", "foobar", true},
	{"", "", "", true},
	{"", "-j", "foobar", true},
	{"", "-j", "foobar", true},
	{"", "-c derp", "foobar", true},
	{"", "--carly=derp", "foobar", true},
	{"", "-j", "foobar", true},
	{"", "-j", "", true},
	{" ", "-j", "foobar", false},
	{"", "", "", true},
	{" ", "", "", false},
	{" ", "-j", "", false},
	{"bat", "", "batbaz", false},
	{"nothing", "", "batbaz", false},
	{"nothing", "", "", false},
	{"nothing", "--jimbob", "batbaz", false},
	{"nothing", "--carly", "", false},
}

func TestCommand_RunDefaultCommandWithFlags(t *testing.T) {
	for _, test := range defaultCommandFlagTests {
		testTitle := fmt.Sprintf("command=%[1]s-flag=%[2]s-default=%[3]s", test.cmdName, test.flag, test.defaultCmd)
		t.Run(testTitle, func(t *testing.T) {
			cmd := &Command{
				DefaultCommand: test.defaultCmd,
				Flags: []Flag{
					&StringFlag{
						Name:     "carly",
						Aliases:  []string{"c"},
						Required: false,
					},
					&BoolFlag{
						Name:     "jimbob",
						Aliases:  []string{"j"},
						Required: false,
						Value:    true,
					},
				},
				Commands: []*Command{
					{
						Name:    "foobar",
						Aliases: []string{"f"},
					},
					{Name: "batbaz", Aliases: []string{"b"}},
				},
			}

			appArgs := []string{"c"}

			if test.flag != "" {
				flags := strings.Split(test.flag, " ")
				if len(flags) > 1 {
					appArgs = append(appArgs, flags...)
				}

				flags = strings.Split(test.flag, "=")
				if len(flags) > 1 {
					appArgs = append(appArgs, flags...)
				}
			}

			appArgs = append(appArgs, test.cmdName)

			err := cmd.Run(buildTestContext(t), appArgs)
			if test.errNotExpected {
				assert.NoError(t, err)
			} else {
				assert.Error(t, err)
			}
		})
	}
}

func TestCommand_FlagsFromExtPackage(t *testing.T) {
	var someint int
	flag.IntVar(&someint, "epflag", 2, "ext package flag usage")

	// Based on source code we can reset the global flag parsing this way
	defer func() {
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
	}()

	cmd := &Command{
		AllowExtFlags: true,
		Flags: []Flag{
			&StringFlag{
				Name:     "carly",
				Aliases:  []string{"c"},
				Required: false,
			},
			&BoolFlag{
				Name:     "jimbob",
				Aliases:  []string{"j"},
				Required: false,
				Value:    true,
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "-c", "cly", "--epflag", "10"})
	assert.NoError(t, err)

	assert.Equal(t, int(10), someint)
	// this exercises the extFlag.Get()
	assert.Equal(t, int(10), cmd.Value("epflag"))

	cmd = &Command{
		Flags: []Flag{
			&StringFlag{
				Name:     "carly",
				Aliases:  []string{"c"},
				Required: false,
			},
			&BoolFlag{
				Name:     "jimbob",
				Aliases:  []string{"j"},
				Required: false,
				Value:    true,
			},
		},
	}

	// this should return an error since epflag shouldn't be registered
	err = cmd.Run(buildTestContext(t), []string{"foo", "-c", "cly", "--epflag", "10"})
	assert.Error(t, err)
}

func TestCommand_Setup_defaultsReader(t *testing.T) {
	cmd := &Command{}
	cmd.setupDefaults([]string{"test"})
	assert.Equal(t, cmd.Reader, os.Stdin)
}

func TestCommand_Setup_defaultsWriter(t *testing.T) {
	cmd := &Command{}
	cmd.setupDefaults([]string{"test"})
	assert.Equal(t, cmd.Writer, os.Stdout)
}

func TestCommand_CommandWithFlagBeforeTerminator(t *testing.T) {
	var parsedOption string
	var args Args

	cmd := &Command{
		Commands: []*Command{
			{
				Name: "cmd",
				Flags: []Flag{
					&StringFlag{Name: "option", Value: "", Usage: "some option"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					parsedOption = cmd.String("option")
					args = cmd.Args()
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"", "cmd", "--option", "my-option", "my-arg", "--", "--notARealFlag"}))

	require.Equal(t, "my-option", parsedOption)
	require.Equal(t, "my-arg", args.Get(0))
	require.Equal(t, "--notARealFlag", args.Get(1))
}

func TestCommand_CommandWithDash(t *testing.T) {
	var args Args

	cmd := &Command{
		Commands: []*Command{
			{
				Name: "cmd",
				Action: func(_ context.Context, cmd *Command) error {
					args = cmd.Args()
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"", "cmd", "my-arg", "-"}))
	require.NotNil(t, args)
	require.Equal(t, "my-arg", args.Get(0))
	require.Equal(t, "-", args.Get(1))
}

func TestCommand_BareDash(t *testing.T) {
	cases := []struct {
		name   string
		argv   []string
		option string
		args   []string
		err    string
	}{
		{
			name: "arguments after a bare dash are kept",
			argv: []string{"", "cmd", "-", "foo", "bar"},
			args: []string{"-", "foo", "bar"},
		},
		{
			name:   "flags after a bare dash still parse",
			argv:   []string{"", "cmd", "-", "--option", "my-option", "foo"},
			option: "my-option",
			args:   []string{"-", "foo"},
		},
		{
			name: "terminator after a bare dash still stops flag parsing",
			argv: []string{"", "cmd", "-", "--", "--option", "leftover"},
			args: []string{"-", "--option", "leftover"},
		},
		{
			name: "a bare dash with surrounding whitespace is passed through unchanged",
			argv: []string{"", "cmd", " - ", "foo"},
			args: []string{" - ", "foo"},
		},
		{
			name: "an undefined flag after a bare dash is an error",
			argv: []string{"", "cmd", "-", "--undefined"},
			err:  "flag provided but not defined: -undefined",
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			var parsedOption string
			var args Args

			cmd := &Command{
				Writer:    io.Discard,
				ErrWriter: io.Discard,
				Commands: []*Command{
					{
						Name: "cmd",
						Flags: []Flag{
							&StringFlag{Name: "option", Value: "", Usage: "some option"},
						},
						Action: func(_ context.Context, cmd *Command) error {
							parsedOption = cmd.String("option")
							args = cmd.Args()
							return nil
						},
					},
				},
			}

			err := cmd.Run(buildTestContext(t), tc.argv)
			if tc.err != "" {
				require.EqualError(t, err, tc.err)
				return
			}
			require.NoError(t, err)
			require.Equal(t, tc.option, parsedOption)
			require.NotNil(t, args)
			require.Equal(t, tc.args, args.Slice())
		})
	}
}

func TestCommand_PositionalArgsKeepWhitespace(t *testing.T) {
	var args Args

	cmd := &Command{
		Name: "prog",
		Action: func(_ context.Context, cmd *Command) error {
			args = cmd.Args()
			return nil
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"prog", "  padded  ", "\ttabbed\t"}))
	require.NotNil(t, args)
	require.Equal(t, []string{"  padded  ", "\ttabbed\t"}, args.Slice())
}

func TestCommand_FlagValuesKeepWhitespace(t *testing.T) {
	cases := []struct {
		name      string
		flag      string
		value     string
		trimSpace bool
	}{
		{name: "empty", flag: "--text"},
		{name: "spaces", flag: "--text", value: " hello "},
		{name: "tab only", flag: "--text", value: "\t"},
		{name: "newline", flag: "--text", value: "line\n"},
		{name: "unicode space", flag: "--text", value: "space\u00a0"},
		{name: "embedded equals", flag: "--text", value: "a=b "},
		{name: "alias", flag: "-t", value: " hello "},
		{name: "leading flag whitespace", flag: "\t --text", value: " hello "},
		{name: "trim enabled", flag: "--text", value: "\t hello \n", trimSpace: true},
	}
	for _, kind := range []string{"string", "slice", "map"} {
		for _, tc := range cases {
			for _, equals := range []bool{false, true} {
				t.Run(fmt.Sprintf("%s/%s/equals=%v", kind, tc.name, equals), func(t *testing.T) {
					config := StringConfig{TrimSpace: tc.trimSpace}
					want := tc.value
					if tc.trimSpace {
						want = strings.TrimSpace(want)
					}
					var fl Flag
					var expected any
					input := tc.value
					switch kind {
					case "string":
						fl = &StringFlag{Name: "text", Aliases: []string{"t"}, Config: config}
						expected = want
					case "slice":
						fl = &StringSliceFlag{Name: "text", Aliases: []string{"t"}, Config: config}
						expected = []string{want}
					case "map":
						fl = &StringMapFlag{Name: "text", Aliases: []string{"t"}, Config: config}
						input = "key=" + tc.value
						expected = map[string]string{"key": want}
					}
					args := []string{"app", tc.flag, input, "operand"}
					if equals {
						args = []string{"app", tc.flag + "=" + input, "operand"}
					}
					cmd := &Command{Flags: []Flag{fl}, Action: func(_ context.Context, cmd *Command) error {
						assert.Equal(t, expected, cmd.Value("text"))
						assert.Equal(t, []string{"operand"}, cmd.Args().Slice())
						return nil
					}}
					require.NoError(t, cmd.Run(buildTestContext(t), args))
				})
			}
		}
	}
}

func TestCommand_SingleRuneUnicodeFlag(t *testing.T) {
	const name = "ש"
	assert.Equal(t, "-", prefixFor(name))

	var value string
	var args []string
	cmd := &Command{
		Name:  "app",
		Flags: []Flag{&StringFlag{Name: name}},
		Action: func(_ context.Context, cmd *Command) error {
			value = cmd.String(name)
			args = cmd.Args().Slice()
			return nil
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"app", "-" + name, "value", "operand"}))
	assert.Equal(t, "value", value)
	assert.Equal(t, []string{"operand"}, args)
}

func TestCommand_DigitFlag(t *testing.T) {
	tests := []struct {
		name          string
		shortOptions  bool
		args          []string
		expectedFour  bool
		expectedSix   bool
		expectedLevel string
		expectedArgs  []string
	}{
		{
			name:         "single digit flag",
			args:         []string{"app", "-4", "operand"},
			expectedFour: true,
			expectedArgs: []string{"operand"},
		},
		{
			name:          "digit flags followed by another flag",
			args:          []string{"app", "-4", "-6", "-level", "high", "operand"},
			expectedFour:  true,
			expectedSix:   true,
			expectedLevel: "high",
			expectedArgs:  []string{"operand"},
		},
		{
			name:          "flag name starting with a digit",
			args:          []string{"app", "-2fa=on", "operand"},
			expectedLevel: "on",
			expectedArgs:  []string{"operand"},
		},
		{
			name:         "digit flags in a short option group",
			shortOptions: true,
			args:         []string{"app", "-46", "operand"},
			expectedFour: true,
			expectedSix:  true,
			expectedArgs: []string{"operand"},
		},
		{
			name:         "undefined digit flag is still a positional argument",
			args:         []string{"app", "-5", "-4"},
			expectedArgs: []string{"-5", "-4"},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			var four, six bool
			var level string
			var args []string
			cmd := &Command{
				Name:                   "app",
				UseShortOptionHandling: test.shortOptions,
				Flags: []Flag{
					&BoolFlag{Name: "4"},
					&BoolFlag{Name: "6"},
					&StringFlag{Name: "level", Aliases: []string{"2fa"}},
				},
				Action: func(_ context.Context, cmd *Command) error {
					four = cmd.Bool("4")
					six = cmd.Bool("6")
					level = cmd.String("level")
					args = cmd.Args().Slice()
					return nil
				},
			}

			require.NoError(t, cmd.Run(buildTestContext(t), test.args))
			assert.Equal(t, test.expectedFour, four)
			assert.Equal(t, test.expectedSix, six)
			assert.Equal(t, test.expectedLevel, level)
			assert.Equal(t, test.expectedArgs, args)
		})
	}
}

func TestCommand_NegativeNumberArg_InvalidFlagAccessHandler(t *testing.T) {
	for _, shortOptions := range []bool{false, true} {
		t.Run(fmt.Sprintf("shortOptions=%v", shortOptions), func(t *testing.T) {
			var invalid []string
			cmd := &Command{
				UseShortOptionHandling: shortOptions,
				InvalidFlagAccessHandler: func(_ context.Context, _ *Command, name string) {
					invalid = append(invalid, name)
				},
				Action: func(context.Context, *Command) error { return nil },
			}

			require.NoError(t, cmd.Run(buildTestContext(t), []string{"app", "-5"}))
			assert.Empty(t, invalid)
		})
	}
}

func TestCommand_EqualsFlagValueValidation(t *testing.T) {
	for _, kind := range []string{"int", "bool"} {
		for _, whitespace := range []string{"", " ", "\t"} {
			t.Run(fmt.Sprintf("%s/whitespace=%q", kind, whitespace), func(t *testing.T) {
				var fl Flag = &IntFlag{Name: "value"}
				value := "42"
				if kind == "bool" {
					fl = &BoolFlag{Name: "value"}
					value = "true"
				}
				actionRan := false
				cmd := &Command{
					Flags: []Flag{fl}, Writer: io.Discard, ErrWriter: io.Discard,
					Action: func(_ context.Context, _ *Command) error { actionRan = true; return nil },
				}
				err := cmd.Run(buildTestContext(t), []string{"app", "--value=" + value + whitespace})
				if whitespace == "" {
					require.NoError(t, err)
					assert.True(t, actionRan)
				} else {
					require.Error(t, err)
					assert.False(t, actionRan)
				}
			})
		}
	}
}

func TestCommand_CommandWithNoFlagBeforeTerminator(t *testing.T) {
	var args Args

	cmd := &Command{
		Commands: []*Command{
			{
				Name: "cmd",
				Action: func(_ context.Context, cmd *Command) error {
					args = cmd.Args()
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"", "cmd", "my-arg", "--", "notAFlagAtAll"}))

	require.NotNil(t, args)
	require.Equal(t, "my-arg", args.Get(0))
	require.Equal(t, "notAFlagAtAll", args.Get(1))
}

func TestCommand_SkipFlagParsing(t *testing.T) {
	var args Args

	cmd := &Command{
		SkipFlagParsing: true,
		Action: func(_ context.Context, cmd *Command) error {
			args = cmd.Args()
			return nil
		},
	}

	_ = cmd.Run(buildTestContext(t), []string{"", "--", "my-arg", "notAFlagAtAll"})

	assert.NotNil(t, args)
	assert.Equal(t, "--", args.Get(0))
	assert.Equal(t, "my-arg", args.Get(1))
	assert.Equal(t, "notAFlagAtAll", args.Get(2))
}

func TestCommand_VisibleCommands(t *testing.T) {
	cmd := &Command{
		Commands: []*Command{
			{
				Name:   "frob",
				Action: func(context.Context, *Command) error { return nil },
			},
			{
				Name:   "frib",
				Hidden: true,
				Action: func(context.Context, *Command) error { return nil },
			},
		},
	}

	cmd.setupDefaults([]string{"test"})
	expected := []*Command{
		cmd.Commands[0],
	}
	actual := cmd.VisibleCommands()
	assert.Len(t, actual, len(expected))
	for i, actualCommand := range actual {
		expectedCommand := expected[i]

		if expectedCommand.Action != nil {
			// comparing func addresses is OK!
			assert.Equal(t, fmt.Sprintf("%p", expectedCommand.Action), fmt.Sprintf("%p", actualCommand.Action))
		}

		func() {
			// nil out funcs, as they cannot be compared
			// (https://github.com/golang/go/issues/8554)
			expectedAction := expectedCommand.Action
			actualAction := actualCommand.Action
			defer func() {
				expectedCommand.Action = expectedAction
				actualCommand.Action = actualAction
			}()
			expectedCommand.Action = nil
			actualCommand.Action = nil

			assert.Equal(t, expectedCommand, actualCommand)
		}()
	}
}

func TestCommand_UseShortOptionHandling(t *testing.T) {
	var one, two bool
	var name string
	expected := "expectedName"

	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	cmd.Flags = []Flag{
		&BoolFlag{Name: "one", Aliases: []string{"o"}},
		&BoolFlag{Name: "two", Aliases: []string{"t"}},
		&StringFlag{Name: "name", Aliases: []string{"n"}},
	}
	cmd.Action = func(_ context.Context, cmd *Command) error {
		one = cmd.Bool("one")
		two = cmd.Bool("two")
		name = cmd.String("name")
		return nil
	}

	_ = cmd.Run(buildTestContext(t), []string{"", "-on", expected})
	assert.True(t, one)
	assert.False(t, two)
	assert.Equal(t, name, expected)
}

func TestCommand_UseShortOptionHandlingBoolWithInverse(t *testing.T) {
	for _, args := range [][]string{{"-c", "-v"}, {"-cv"}, {"-vc"}} {
		t.Run(strings.Join(args, " "), func(t *testing.T) {
			cmd := &Command{
				Name:                   "app",
				UseShortOptionHandling: true,
				Flags: []Flag{
					&BoolWithInverseFlag{Name: "color", Aliases: []string{"c"}},
					&BoolFlag{Name: "verbose", Aliases: []string{"v"}},
				},
				Writer:    io.Discard,
				ErrWriter: io.Discard,
			}

			require.NoError(t, cmd.Run(buildTestContext(t), append([]string{"app"}, args...)))
			assert.True(t, cmd.Bool("color"))
			assert.True(t, cmd.Bool("verbose"))
		})
	}
}

func TestCommand_UseShortOptionHandling_missing_value(t *testing.T) {
	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	cmd.Flags = []Flag{
		&StringFlag{Name: "name", Aliases: []string{"n"}},
	}

	err := cmd.Run(buildTestContext(t), []string{"", "-n"})
	assert.EqualError(t, err, "flag needs an argument: -n")
}

func TestCommand_UseShortOptionHandlingMultiByteLastFlag(t *testing.T) {
	const name = "ש"

	var verbose bool
	var value string
	var args []string
	newCmd := func() *Command {
		return &Command{
			Name:                   "app",
			UseShortOptionHandling: true,
			Flags: []Flag{
				&BoolFlag{Name: "v"},
				&StringFlag{Name: name},
			},
			Action: func(_ context.Context, cmd *Command) error {
				verbose = cmd.Bool("v")
				value = cmd.String(name)
				args = cmd.Args().Slice()
				return nil
			},
			Writer:    io.Discard,
			ErrWriter: io.Discard,
		}
	}

	require.NoError(t, newCmd().Run(buildTestContext(t), []string{"app", "-v" + name, "value", "operand"}))
	assert.True(t, verbose)
	assert.Equal(t, "value", value)
	assert.Equal(t, []string{"operand"}, args)

	err := newCmd().Run(buildTestContext(t), []string{"app", "-v" + name})
	assert.EqualError(t, err, "flag needs an argument: "+name)
}

func TestCommand_UseShortOptionHandlingValueForLastFlag(t *testing.T) {
	var verbose, extra bool
	var value string
	var args []string
	newCmd := func() *Command {
		return &Command{
			Name:                   "app",
			UseShortOptionHandling: true,
			Flags: []Flag{
				&BoolFlag{Name: "v"},
				&BoolFlag{Name: "x"},
				&StringFlag{Name: "n"},
			},
			Action: func(_ context.Context, cmd *Command) error {
				verbose = cmd.Bool("v")
				extra = cmd.Bool("x")
				value = cmd.String("n")
				args = cmd.Args().Slice()
				return nil
			},
			Writer:    io.Discard,
			ErrWriter: io.Discard,
		}
	}

	require.NoError(t, newCmd().Run(buildTestContext(t), []string{"app", "-vn=value", "operand"}))
	assert.True(t, verbose)
	assert.Equal(t, "value", value)
	assert.Equal(t, []string{"operand"}, args)

	require.NoError(t, newCmd().Run(buildTestContext(t), []string{"app", "-vx=false"}))
	assert.True(t, verbose)
	assert.False(t, extra)
}

func TestCommand_UseShortOptionHandlingCommand(t *testing.T) {
	var (
		one, two bool
		name     string
		expected = "expectedName"
	)

	cmd := &Command{
		Name: "cmd",
		Flags: []Flag{
			&BoolFlag{Name: "one", Aliases: []string{"o"}},
			&BoolFlag{Name: "two", Aliases: []string{"t"}},
			&StringFlag{Name: "name", Aliases: []string{"n"}},
		},
		Action: func(_ context.Context, cmd *Command) error {
			one = cmd.Bool("one")
			two = cmd.Bool("two")
			name = cmd.String("name")
			return nil
		},
		UseShortOptionHandling: true,
		Writer:                 io.Discard,
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"cmd", "-on", expected}))
	require.True(t, one)
	require.False(t, two)
	require.Equal(t, expected, name)
}

func TestCommand_UseShortOptionHandlingCommand_missing_value(t *testing.T) {
	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	command := &Command{
		Name: "cmd",
		Flags: []Flag{
			&StringFlag{Name: "name", Aliases: []string{"n"}},
		},
	}
	cmd.Commands = []*Command{command}

	require.EqualError(
		t,
		cmd.Run(buildTestContext(t), []string{"", "cmd", "-n"}),
		"flag needs an argument: -n",
	)
}

func TestCommand_UseShortOptionHandlingSubCommand(t *testing.T) {
	var one, two bool
	var name string

	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	cmd.Commands = []*Command{
		{
			Name: "cmd",
			Commands: []*Command{
				{
					Name: "sub",
					Flags: []Flag{
						&BoolFlag{Name: "one", Aliases: []string{"o"}},
						&BoolFlag{Name: "two", Aliases: []string{"t"}},
						&StringFlag{Name: "name", Aliases: []string{"n"}},
					},
					Action: func(_ context.Context, cmd *Command) error {
						one = cmd.Bool("one")
						two = cmd.Bool("two")
						name = cmd.String("name")
						return nil
					},
				},
			},
		},
	}

	expected := "expectedName"

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"", "cmd", "sub", "-on", expected}))
	require.True(t, one)
	require.False(t, two)
	require.Equal(t, expected, name)
}

func TestCommand_UseShortOptionHandlingSubCommand_missing_value(t *testing.T) {
	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	command := &Command{
		Name: "cmd",
	}
	subCommand := &Command{
		Name: "sub",
		Flags: []Flag{
			&StringFlag{Name: "name", Aliases: []string{"n"}},
		},
	}
	command.Commands = []*Command{subCommand}
	cmd.Commands = []*Command{command}

	err := cmd.Run(buildTestContext(t), []string{"", "cmd", "sub", "-n"})
	assert.EqualError(t, err, "flag needs an argument: -n")
}

func TestCommand_UseShortOptionHandlingLocalFlagNotInherited(t *testing.T) {
	// A parent's Local flag is not applied to its subcommands, so it must be
	// rejected inside a short option group too, as in long form (see
	// TestLocalFlagError).
	tests := []struct {
		arg     string
		wantErr string
	}{
		{arg: "-d", wantErr: "flag provided but not defined: -d"},
		{arg: "-xd", wantErr: "flag provided but not defined: -xd"},
		{arg: "-dx", wantErr: "flag provided but not defined: -dx"},
		// reported before -s, which needs an argument but is not last
		{arg: "-sd", wantErr: "flag provided but not defined: -sd"},
		{arg: "-xy"}, // the subcommand's own flags still work
	}
	for _, tt := range tests {
		t.Run(tt.arg, func(t *testing.T) {
			var x, y bool
			cmd := &Command{
				Name:                   "app",
				UseShortOptionHandling: true,
				Flags: []Flag{
					&BoolFlag{Name: "debug", Aliases: []string{"d"}, Local: true},
				},
				Commands: []*Command{
					{
						Name: "sub",
						Flags: []Flag{
							&BoolFlag{Name: "x", Destination: &x},
							&BoolFlag{Name: "y", Destination: &y},
							&StringFlag{Name: "s"},
						},
					},
				},
				Writer:    io.Discard,
				ErrWriter: io.Discard,
			}

			err := cmd.Run(buildTestContext(t), []string{"app", "sub", tt.arg})
			if tt.wantErr != "" {
				assert.EqualError(t, err, tt.wantErr)
				return
			}
			require.NoError(t, err)
			assert.True(t, x)
			assert.True(t, y)
		})
	}
}

func TestCommand_UseShortOptionAfterSliceFlag(t *testing.T) {
	var one, two bool
	var name string
	var sliceValDest []string
	var sliceVal []string
	expected := "expectedName"

	cmd := buildMinimalTestCommand()
	cmd.UseShortOptionHandling = true
	cmd.Flags = []Flag{
		&StringSliceFlag{Name: "env", Aliases: []string{"e"}, Destination: &sliceValDest},
		&BoolFlag{Name: "one", Aliases: []string{"o"}},
		&BoolFlag{Name: "two", Aliases: []string{"t"}},
		&StringFlag{Name: "name", Aliases: []string{"n"}},
	}
	cmd.Action = func(_ context.Context, cmd *Command) error {
		sliceVal = cmd.StringSlice("env")
		one = cmd.Bool("one")
		two = cmd.Bool("two")
		name = cmd.String("name")
		return nil
	}

	_ = cmd.Run(buildTestContext(t), []string{"", "-e", "foo", "-on", expected})
	assert.Equal(t, sliceVal, []string{"foo"})
	assert.Equal(t, sliceValDest, []string{"foo"})
	assert.True(t, one)
	assert.False(t, two)
	assert.Equal(t, expected, name)
}

func TestCommand_UseShortOptionWithArg(t *testing.T) {
	var rootPath string
	cmd := &Command{
		UseShortOptionHandling: true,
		Commands: []*Command{
			{
				Name:  "short",
				Usage: "complete a task on the list",
				Arguments: []Argument{
					&StringArg{Name: "root", UsageText: "Root path", Destination: &rootPath},
				},
				Flags: []Flag{
					&BoolFlag{Name: "serve", Aliases: []string{"s"}},
					&BoolFlag{Name: "option", Aliases: []string{"o"}},
					&StringFlag{Name: "message", Aliases: []string{"m"}},
				},
				Action: func(ctx context.Context, cmd *Command) error {
					return nil
				},
			},
		},
	}
	err := cmd.Run(buildTestContext(t), []string{"app", "short", "-som", "hello", "/path/to/root"})
	require.NoError(t, err)
	require.Equal(t, "/path/to/root", rootPath)
}

func TestCommand_Float64Flag(t *testing.T) {
	var meters float64

	cmd := &Command{
		Flags: []Flag{
			&FloatFlag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
		},
		Action: func(_ context.Context, cmd *Command) error {
			meters = cmd.Float("height")
			return nil
		},
	}

	_ = cmd.Run(buildTestContext(t), []string{"", "--height", "1.93"})
	assert.Equal(t, 1.93, meters)
}

func TestCommand_ParseSliceFlags(t *testing.T) {
	var parsedIntSlice []int64
	var parsedStringSlice []string

	cmd := &Command{
		Commands: []*Command{
			{
				Name: "cmd",
				Flags: []Flag{
					&Int64SliceFlag{Name: "p", Value: []int64{}, Usage: "set one or more ip addr"},
					&StringSliceFlag{Name: "ip", Value: []string{}, Usage: "set one or more ports to open"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					parsedIntSlice = cmd.Int64Slice("p")
					parsedStringSlice = cmd.StringSlice("ip")
					return nil
				},
			},
		},
	}

	r := require.New(t)

	r.NoError(cmd.Run(buildTestContext(t), []string{"", "cmd", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"}))
	r.Equal([]int64{22, 80}, parsedIntSlice)
	r.Equal([]string{"8.8.8.8", "8.8.4.4"}, parsedStringSlice)
}

func TestCommand_ParseSliceFlagsWithMissingValue(t *testing.T) {
	var parsedIntSlice []int64
	var parsedStringSlice []string

	cmd := &Command{
		Commands: []*Command{
			{
				Name: "cmd",
				Flags: []Flag{
					&Int64SliceFlag{Name: "a", Usage: "set numbers"},
					&StringSliceFlag{Name: "str", Usage: "set strings"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					parsedIntSlice = cmd.Int64Slice("a")
					parsedStringSlice = cmd.StringSlice("str")
					return nil
				},
			},
		},
	}

	r := require.New(t)

	r.NoError(cmd.Run(buildTestContext(t), []string{"", "cmd", "-a", "2", "-str", "A"}))
	r.Equal([]int64{2}, parsedIntSlice)
	r.Equal([]string{"A"}, parsedStringSlice)
}

func TestCommand_DefaultStdin(t *testing.T) {
	cmd := &Command{}
	cmd.setupDefaults([]string{"test"})

	assert.Equal(t, cmd.Reader, os.Stdin, "Default input reader not set.")
}

func TestCommand_DefaultStdout(t *testing.T) {
	cmd := &Command{}
	cmd.setupDefaults([]string{"test"})

	assert.Equal(t, cmd.Writer, os.Stdout, "Default output writer not set.")
}

func TestCommand_SetStdin(t *testing.T) {
	buf := make([]byte, 12)

	cmd := &Command{
		Name:   "test",
		Reader: strings.NewReader("Hello World!"),
		Action: func(_ context.Context, cmd *Command) error {
			_, err := cmd.Reader.Read(buf)
			return err
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"help"})
	require.NoError(t, err)
	assert.Equal(t, "Hello World!", string(buf), "Command did not read input from desired reader.")
}

func TestCommand_SetStdin_Subcommand(t *testing.T) {
	buf := make([]byte, 12)

	cmd := &Command{
		Name:   "test",
		Reader: strings.NewReader("Hello World!"),
		Commands: []*Command{
			{
				Name: "command",
				Commands: []*Command{
					{
						Name: "subcommand",
						Action: func(_ context.Context, cmd *Command) error {
							_, err := cmd.Root().Reader.Read(buf)
							return err
						},
					},
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"test", "command", "subcommand"})
	require.NoError(t, err)
	assert.Equal(t, "Hello World!", string(buf), "Command did not read input from desired reader.")
}

func TestCommand_SetStdout(t *testing.T) {
	var w bytes.Buffer

	cmd := &Command{
		Name:   "test",
		Writer: &w,
	}

	err := cmd.Run(buildTestContext(t), []string{"help"})
	require.NoError(t, err)
	assert.NotZero(t, w.Len(), "Command did not write output to desired writer.")
}

func TestCommand_BeforeFunc(t *testing.T) {
	counts := &opCounts{}
	beforeError := fmt.Errorf("fail")
	var err error

	cmd := &Command{
		Before: func(_ context.Context, cmd *Command) (context.Context, error) {
			counts.Total++
			counts.Before = counts.Total
			s := cmd.String("opt")
			if s == "fail" {
				return nil, beforeError
			}

			return nil, nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					counts.Total++
					counts.SubCommand = counts.Total
					return nil
				},
			},
		},
		Flags: []Flag{
			&StringFlag{Name: "opt"},
		},
		Writer: io.Discard,
	}

	// run with the Before() func succeeding
	err = cmd.Run(buildTestContext(t), []string{"command", "--opt", "succeed", "sub"})
	require.NoError(t, err)

	assert.Equal(t, 1, counts.Before, "Before() not executed when expected")
	assert.Equal(t, 2, counts.SubCommand, "Subcommand not executed when expected")

	// reset
	counts = &opCounts{}

	// run with the Before() func failing
	err = cmd.Run(buildTestContext(t), []string{"command", "--opt", "fail", "sub"})

	// should be the same error produced by the Before func
	assert.ErrorIs(t, err, beforeError, "Run error expected, but not received")
	assert.Equal(t, 1, counts.Before, "Before() not executed when expected")
	assert.Equal(t, 0, counts.SubCommand, "Subcommand executed when NOT expected")

	// reset
	counts = &opCounts{}

	afterError := errors.New("fail again")
	cmd.After = func(context.Context, *Command) error {
		return afterError
	}

	// run with the Before() func failing, wrapped by After()
	err = cmd.Run(buildTestContext(t), []string{"command", "--opt", "fail", "sub"})

	// should be the same error produced by the Before func
	if _, ok := err.(MultiError); !ok {
		t.Errorf("MultiError expected, but not received")
	}

	assert.Equal(t, 1, counts.Before, "Before() not executed when expected")
	assert.Zero(t, counts.SubCommand, "Subcommand executed when NOT expected")
}

func TestCommand_BeforeFuncPersistentFlag(t *testing.T) {
	counts := &opCounts{}
	beforeError := fmt.Errorf("fail")
	var err error

	cmd := &Command{
		Before: func(_ context.Context, cmd *Command) (context.Context, error) {
			counts.Before++
			s := cmd.String("opt")
			if s != "value" {
				return nil, beforeError
			}
			return nil, nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					counts.SubCommand++
					return nil
				},
			},
		},
		Flags: []Flag{
			&StringFlag{Name: "opt"},
		},
		Writer: io.Discard,
	}

	// Check that --opt value is available in root command Before hook,
	// even when it was set on the subcommand.
	err = cmd.Run(buildTestContext(t), []string{"command", "sub", "--opt", "value"})
	require.NoError(t, err)
	assert.Equal(t, 1, counts.Before, "Before() not executed when expected")
	assert.Equal(t, 1, counts.SubCommand, "Subcommand not executed when expected")
}

func TestCommand_BeforeAfterFuncShellCompletion(t *testing.T) {
	t.Skip("TODO: is '--generate-shell-completion' (flag) still supported?")

	counts := &opCounts{}

	cmd := &Command{
		EnableShellCompletion: true,
		Before: func(context.Context, *Command) (context.Context, error) {
			counts.Total++
			counts.Before = counts.Total
			return nil, nil
		},
		After: func(context.Context, *Command) error {
			counts.Total++
			counts.After = counts.Total
			return nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					counts.Total++
					counts.SubCommand = counts.Total
					return nil
				},
			},
		},
		Flags: []Flag{
			&StringFlag{Name: "opt"},
		},
		Writer: io.Discard,
	}

	r := require.New(t)

	// run with the Before() func succeeding
	r.NoError(
		cmd.Run(
			buildTestContext(t),
			[]string{
				"command",
				"--opt", "succeed",
				"sub", completionFlag,
			},
		),
	)

	r.Equalf(0, counts.Before, "Before was run")
	r.Equal(0, counts.After, "After was run")
	r.Equal(0, counts.SubCommand, "SubCommand was run")
}

func TestCommand_AfterFunc(t *testing.T) {
	counts := &opCounts{}
	afterError := fmt.Errorf("fail")
	var err error

	cmd := &Command{
		After: func(_ context.Context, cmd *Command) error {
			counts.Total++
			counts.After = counts.Total
			s := cmd.String("opt")
			if s == "fail" {
				return afterError
			}

			return nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					counts.Total++
					counts.SubCommand = counts.Total
					return nil
				},
			},
		},
		Flags: []Flag{
			&StringFlag{Name: "opt"},
		},
	}

	// run with the After() func succeeding
	err = cmd.Run(buildTestContext(t), []string{"command", "--opt", "succeed", "sub"})
	require.NoError(t, err)
	assert.Equal(t, 2, counts.After, "After() not executed when expected")
	assert.Equal(t, 1, counts.SubCommand, "Subcommand not executed when expected")

	// reset
	counts = &opCounts{}

	// run with the Before() func failing
	err = cmd.Run(buildTestContext(t), []string{"command", "--opt", "fail", "sub"})

	// should be the same error produced by the Before func
	assert.ErrorIs(t, err, afterError, "Run error expected, but not received")
	assert.Equal(t, 2, counts.After, "After() not executed when expected")
	assert.Equal(t, 1, counts.SubCommand, "Subcommand not executed when expected")

	/*
		reset
	*/
	counts = &opCounts{}
	// reset the flags since they are set previously
	cmd.Flags = []Flag{
		&StringFlag{Name: "opt"},
	}

	// run with none args
	err = cmd.Run(buildTestContext(t), []string{"command"})

	// should be the same error produced by the Before func
	require.NoError(t, err)

	assert.Equal(t, 1, counts.After, "After() not executed when expected")
	assert.Equal(t, 0, counts.SubCommand, "Subcommand not executed when expected")
}

func TestCommand_AfterNotCalledOnSubcommandHelp(t *testing.T) {
	var afterCalled bool
	cmd := &Command{
		After: func(_ context.Context, _ *Command) error {
			afterCalled = true
			return nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					return nil
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"app", "sub", "--help"})
	require.NoError(t, err)
	assert.False(t, afterCalled, "After should not be called when --help is passed to subcommand")
}

func TestCommand_AfterStillCalledOnNormalSubcommand(t *testing.T) {
	var afterCalled bool
	cmd := &Command{
		After: func(_ context.Context, _ *Command) error {
			afterCalled = true
			return nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(context.Context, *Command) error {
					return nil
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"app", "sub"})
	require.NoError(t, err)
	assert.True(t, afterCalled, "After should be called on normal subcommand execution")
}

func TestCommandNoHelpFlag(t *testing.T) {
	oldFlag := HelpFlag
	defer func() {
		HelpFlag = oldFlag
	}()

	HelpFlag = nil

	cmd := &Command{Writer: io.Discard}

	err := cmd.Run(buildTestContext(t), []string{"test", "-h"})

	assert.ErrorContains(t, err, providedButNotDefinedErrMsg, "expected error about missing help flag")
}

func TestRequiredFlagCommandRunBehavior(t *testing.T) {
	tdata := []struct {
		testCase        string
		appFlags        []Flag
		appRunInput     []string
		appCommands     []*Command
		expectedAnError bool
	}{
		// assertion: empty input, when a required flag is present, errors
		{
			testCase:        "error_case_empty_input_with_required_flag_on_app",
			appRunInput:     []string{"myCLI"},
			appFlags:        []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
			expectedAnError: true,
		},
		{
			testCase:    "error_case_empty_input_with_required_flag_on_command",
			appRunInput: []string{"myCLI", "myCommand"},
			appCommands: []*Command{{
				Name:  "myCommand",
				Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
			}},
			expectedAnError: true,
		},
		{
			testCase:    "error_case_empty_input_with_required_flag_on_subcommand",
			appRunInput: []string{"myCLI", "myCommand", "mySubCommand"},
			appCommands: []*Command{{
				Name: "myCommand",
				Commands: []*Command{{
					Name:  "mySubCommand",
					Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
				}},
			}},
			expectedAnError: true,
		},
		// assertion: inputting --help, when a required flag is present, does not error
		{
			testCase:    "valid_case_help_input_with_required_flag_on_app",
			appRunInput: []string{"myCLI", "--help"},
			appFlags:    []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
		},
		{
			testCase:    "valid_case_help_input_with_required_flag_on_command",
			appRunInput: []string{"myCLI", "myCommand", "--help"},
			appCommands: []*Command{{
				Name:  "myCommand",
				Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
			}},
		},
		{
			testCase:    "valid_case_help_input_with_required_flag_on_subcommand",
			appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--help"},
			appCommands: []*Command{{
				Name: "myCommand",
				Commands: []*Command{{
					Name:  "mySubCommand",
					Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
				}},
			}},
		},
		// assertion: giving optional input, when a required flag is present, errors
		{
			testCase:        "error_case_optional_input_with_required_flag_on_app",
			appRunInput:     []string{"myCLI", "--optional", "cats"},
			appFlags:        []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}},
			expectedAnError: true,
		},
		{
			testCase:    "error_case_optional_input_with_required_flag_on_command",
			appRunInput: []string{"myCLI", "myCommand", "--optional", "cats"},
			appCommands: []*Command{{
				Name:  "myCommand",
				Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}},
			}},
			expectedAnError: true,
		},
		{
			testCase:    "error_case_optional_input_with_required_flag_on_subcommand",
			appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--optional", "cats"},
			appCommands: []*Command{{
				Name: "myCommand",
				Commands: []*Command{{
					Name:  "mySubCommand",
					Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}},
				}},
			}},
			expectedAnError: true,
		},
		// assertion: when a required flag is present, inputting that required flag does not error
		{
			testCase:    "valid_case_required_flag_input_on_app",
			appRunInput: []string{"myCLI", "--requiredFlag", "cats"},
			appFlags:    []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
		},
		{
			testCase:    "valid_case_required_flag_input_on_command",
			appRunInput: []string{"myCLI", "myCommand", "--requiredFlag", "cats"},
			appCommands: []*Command{{
				Name:  "myCommand",
				Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
			}},
		},
		{
			testCase:    "valid_case_required_flag_input_on_subcommand",
			appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--requiredFlag", "cats"},
			appCommands: []*Command{{
				Name: "myCommand",
				Commands: []*Command{{
					Name:  "mySubCommand",
					Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}},
					Action: func(context.Context, *Command) error {
						return nil
					},
				}},
			}},
		},
	}
	for _, test := range tdata {
		t.Run(test.testCase, func(t *testing.T) {
			// setup
			cmd := buildMinimalTestCommand()
			cmd.Flags = test.appFlags
			cmd.Commands = test.appCommands

			// logic under test
			err := cmd.Run(buildTestContext(t), test.appRunInput)

			// assertions
			if test.expectedAnError {
				assert.Error(t, err)
				if _, ok := err.(requiredFlagsErr); test.expectedAnError && !ok {
					t.Errorf("expected a requiredFlagsErr, but got: %s", err)
				}
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestCommand_IncorrectUsageOnRequiredFlagsViaRun(t *testing.T) {
	t.Run("root command missing required flag", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "command")
	})

	t.Run("subcommand missing required flag", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Commands: []*Command{
				{
					Name: "sub",
					Flags: []Flag{
						&StringFlag{Name: "requiredFlag", Required: true},
					},
					Action: func(ctx context.Context, cmd *Command) error {
						return nil
					},
				},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command", "sub"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "sub")
	})
}

func TestCommand_IncorrectUsageOnMutuallyExclusiveFlagsViaRun(t *testing.T) {
	t.Run("root command with mutex violation", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
				{
					Flags: [][]Flag{
						{&StringFlag{Name: "foo1"}},
						{&StringFlag{Name: "foo2"}},
					},
				},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command", "--foo1", "v1", "--foo2", "v2"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "command")
	})

	t.Run("subcommand with mutex violation", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
			Commands: []*Command{
				{
					Name: "sub",
					MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
						{
							Flags: [][]Flag{
								{&StringFlag{Name: "foo1"}},
								{&StringFlag{Name: "foo2"}},
							},
						},
					},
				},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command", "sub", "--foo1", "v1", "--foo2", "v2"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "sub")
	})
}

func TestCommand_IncorrectUsageOnSubcommandWithFailingShowCommandHelp(t *testing.T) {
	t.Run("required flags fallback to ShowSubcommandHelp", func(t *testing.T) {
		oldShowCommandHelp := ShowCommandHelp
		defer func() { ShowCommandHelp = oldShowCommandHelp }()
		ShowCommandHelp = func(_ context.Context, _ *Command, _ string) error {
			return errors.New("forced error")
		}

		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Commands: []*Command{
				{
					Name: "sub",
					Flags: []Flag{
						&StringFlag{Name: "requiredFlag", Required: true},
					},
					Action: func(ctx context.Context, cmd *Command) error {
						return nil
					},
				},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command", "sub"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "sub")
	})

	t.Run("mutex flags fallback to ShowSubcommandHelp", func(t *testing.T) {
		oldShowCommandHelp := ShowCommandHelp
		defer func() { ShowCommandHelp = oldShowCommandHelp }()
		ShowCommandHelp = func(_ context.Context, _ *Command, _ string) error {
			return errors.New("forced error")
		}

		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
			Commands: []*Command{
				{
					Name: "sub",
					MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
						{
							Flags: [][]Flag{
								{&StringFlag{Name: "foo1"}},
								{&StringFlag{Name: "foo2"}},
							},
						},
					},
				},
			},
		}

		_ = cmd.Run(buildTestContext(t), []string{"command", "sub", "--foo1", "v1", "--foo2", "v2"})
		r.Contains(errBuf.String(), "Incorrect Usage")
		r.Contains(buf.String(), "sub")
	})
}

func TestCommandHelpPrinter(t *testing.T) {
	oldPrinter := HelpPrinter
	defer func() {
		HelpPrinter = oldPrinter
	}()

	wasCalled := false
	HelpPrinter = func(io.Writer, string, any) {
		wasCalled = true
	}

	cmd := &Command{}

	_ = cmd.Run(buildTestContext(t), []string{"-h"})

	assert.True(t, wasCalled, "Help printer expected to be called, but was not")
}

func TestCommand_VersionPrinter(t *testing.T) {
	oldPrinter := VersionPrinter
	defer func() {
		VersionPrinter = oldPrinter
	}()

	wasCalled := false
	VersionPrinter = func(*Command) {
		wasCalled = true
	}

	cmd := &Command{}
	ShowVersion(cmd)

	assert.True(t, wasCalled, "Version printer expected to be called, but was not")
}

func TestCommand_CommandNotFound(t *testing.T) {
	counts := &opCounts{}
	cmd := &Command{
		CommandNotFound: func(context.Context, *Command, string) {
			counts.Total++
			counts.CommandNotFound = counts.Total
		},
		Commands: []*Command{
			{
				Name: "bar",
				Action: func(context.Context, *Command) error {
					counts.Total++
					counts.SubCommand = counts.Total
					return nil
				},
			},
		},
	}

	_ = cmd.Run(buildTestContext(t), []string{"command", "foo"})

	assert.Equal(t, 1, counts.CommandNotFound)
	assert.Equal(t, 0, counts.SubCommand)
	assert.Equal(t, 1, counts.Total)
}

func TestCommand_OrderOfOperations(t *testing.T) {
	buildCmdCounts := func() (*Command, *opCounts) {
		counts := &opCounts{}

		cmd := &Command{
			EnableShellCompletion: true,
			ShellComplete: func(context.Context, *Command) {
				counts.Total++
				counts.ShellComplete = counts.Total
			},
			OnUsageError: func(context.Context, *Command, error, bool) error {
				counts.Total++
				counts.OnUsageError = counts.Total
				return errors.New("hay OnUsageError")
			},
			Writer: io.Discard,
		}

		beforeNoError := func(context.Context, *Command) (context.Context, error) {
			counts.Total++
			counts.Before = counts.Total
			return nil, nil
		}

		cmd.Before = beforeNoError
		cmd.CommandNotFound = func(context.Context, *Command, string) {
			counts.Total++
			counts.CommandNotFound = counts.Total
		}

		afterNoError := func(context.Context, *Command) error {
			counts.Total++
			counts.After = counts.Total
			return nil
		}

		cmd.After = afterNoError
		cmd.Commands = []*Command{
			{
				Name: "bar",
				Action: func(context.Context, *Command) error {
					counts.Total++
					counts.SubCommand = counts.Total
					return nil
				},
			},
		}

		cmd.Action = func(context.Context, *Command) error {
			counts.Total++
			counts.Action = counts.Total
			return nil
		}

		return cmd, counts
	}

	t.Run("on usage error", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command", "--nope"})
		r.Equal(1, counts.OnUsageError)
		r.Equal(1, counts.Total)
	})

	t.Run("shell complete", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command", completionFlag})
		r.Equal(1, counts.Before)
		r.Equal(2, counts.ShellComplete)
		r.Equal(2, counts.Total)
	})

	t.Run("nil on usage error", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		cmd.OnUsageError = nil

		_ = cmd.Run(buildTestContext(t), []string{"command", "--nope"})
		require.Equal(t, 0, counts.Total)
	})

	t.Run("before after action hooks", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command", "foo"})
		r.Equal(0, counts.OnUsageError)
		r.Equal(1, counts.Before)
		r.Equal(0, counts.CommandNotFound)
		r.Equal(2, counts.Action)
		r.Equal(3, counts.After)
		r.Equal(3, counts.Total)
	})

	t.Run("before with error", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		cmd.Before = func(context.Context, *Command) (context.Context, error) {
			counts.Total++
			counts.Before = counts.Total
			return nil, errors.New("hay Before")
		}

		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command", "bar"})
		r.Equal(0, counts.OnUsageError)
		r.Equal(1, counts.Before)
		r.Equal(2, counts.After)
		r.Equal(2, counts.Total)
	})

	t.Run("nil after", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		cmd.After = nil
		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command", "bar"})
		r.Equal(0, counts.OnUsageError)
		r.Equal(1, counts.Before)
		r.Equal(2, counts.SubCommand)
		r.Equal(2, counts.Total)
	})

	t.Run("after errors", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		cmd.After = func(context.Context, *Command) error {
			counts.Total++
			counts.After = counts.Total
			return errors.New("hay After")
		}

		r := require.New(t)

		err := cmd.Run(buildTestContext(t), []string{"command", "bar"})
		r.Error(err)
		r.Equal(0, counts.OnUsageError)
		r.Equal(1, counts.Before)
		r.Equal(2, counts.SubCommand)
		r.Equal(3, counts.After)
		r.Equal(3, counts.Total)
	})

	t.Run("nil commands", func(t *testing.T) {
		cmd, counts := buildCmdCounts()
		cmd.Commands = nil
		r := require.New(t)

		_ = cmd.Run(buildTestContext(t), []string{"command"})
		r.Equal(0, counts.OnUsageError)
		r.Equal(1, counts.Before)
		r.Equal(2, counts.Action)
		r.Equal(3, counts.After)
		r.Equal(3, counts.Total)
	})
}

func TestCommand_HelpFlagTakesPrecedenceOverParseErrors(t *testing.T) {
	t.Run("root command with --help and bad flag", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"command", "--help", "--undefined"})
		r.NoError(err)
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "command")
		r.NotContains(errBuf.String(), "Incorrect Usage")
	})

	t.Run("root command with -h and bad flag", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"command", "-h", "--undefined"})
		r.NoError(err)
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "command")
		r.NotContains(errBuf.String(), "Incorrect Usage")
	})

	t.Run("subcommand with --help and bad flag", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
			Commands: []*Command{
				{
					Name: "foo",
					Action: func(ctx context.Context, cmd *Command) error {
						return nil
					},
				},
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"command", "foo", "--help", "--undefined"})
		r.NoError(err)
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "foo")
		r.NotContains(errBuf.String(), "Incorrect Usage")
	})

	t.Run("subcommand with bad flag shows Incorrect Usage and help", func(t *testing.T) {
		r := require.New(t)
		var buf bytes.Buffer
		var errBuf bytes.Buffer

		cmd := &Command{
			Writer:    &buf,
			ErrWriter: &errBuf,
			Action: func(ctx context.Context, cmd *Command) error {
				return nil
			},
			Commands: []*Command{
				{
					Name: "foo",
					Action: func(ctx context.Context, cmd *Command) error {
						return nil
					},
				},
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"command", "foo", "--undefined"})
		r.Error(err)
		r.Contains(buf.String(), "NAME:")
		r.Contains(buf.String(), "foo")
		r.Contains(errBuf.String(), "Incorrect Usage")
	})
}

func TestFlagActionOrder(t *testing.T) {
	tests := []struct {
		Name string
		Args []string
	}{
		{
			Name: "abc",
			Args: []string{"", "--a", "--b", "--c"},
		},
		{
			Name: "bca",
			Args: []string{"", "--b", "--c", "--a"},
		},
		{
			Name: "cba",
			Args: []string{"", "--c", "--b", "--a"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.Name, func(t *testing.T) {
			str := ""
			action := func(name string) func(context.Context, *Command, bool) error {
				return func(_ context.Context, _ *Command, _ bool) error {
					str += name
					return nil
				}
			}
			cmd := &Command{
				Flags: []Flag{
					&BoolFlag{Name: "a", Action: action("a")},
					&BoolFlag{Name: "b", Action: action("b")},
					&BoolFlag{Name: "c", Action: action("c")},
				},
				Action: func(_ context.Context, cmd *Command) error {
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), tt.Args)
			require.NoError(t, err)

			if str != "abc" {
				t.Errorf("expected 'abc' got '%s'", str)
			}
		})
	}
}

func TestCommand_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
	subcommandHelpTopics := [][]string{
		{"foo", "--help"},
		{"foo", "-h"},
		{"foo", "help"},
	}

	for _, flagSet := range subcommandHelpTopics {
		t.Run(fmt.Sprintf("checking with flags %v", flagSet), func(t *testing.T) {
			buf := new(bytes.Buffer)

			subCmdBar := &Command{
				Name:  "bar",
				Usage: "does bar things",
			}
			subCmdBaz := &Command{
				Name:  "baz",
				Usage: "does baz things",
			}
			cmd := &Command{
				Name:        "foo",
				Description: "descriptive wall of text about how it does foo things",
				Commands:    []*Command{subCmdBar, subCmdBaz},
				Action:      func(context.Context, *Command) error { return nil },
				Writer:      buf,
			}

			err := cmd.Run(buildTestContext(t), flagSet)
			assert.NoError(t, err)

			output := buf.String()

			assert.NotContains(t, output, "No help topic for", "expect a help topic, got none")

			for _, shouldContain := range []string{
				cmd.Name, cmd.Description,
				subCmdBar.Name, subCmdBar.Usage,
				subCmdBaz.Name, subCmdBaz.Usage,
			} {
				assert.Contains(t, output, shouldContain, "want help to contain %q, did not: \n%q", shouldContain, output)
			}
		})
	}
}

func TestCommand_Run_SubcommandFullPath(t *testing.T) {
	out := &bytes.Buffer{}

	subCmd := &Command{
		Name:      "bar",
		Usage:     "does bar things",
		ArgsUsage: "[arguments...]",
	}

	cmd := &Command{
		Name:        "foo",
		Description: "foo commands",
		Commands:    []*Command{subCmd},
		Writer:      out,
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"foo", "bar", "--help"}))

	outString := out.String()
	require.Contains(t, outString, "foo bar - does bar things")
	require.Contains(t, outString, "foo bar [options] [arguments...]")
}

func TestCommand_Run_Help(t *testing.T) {
	tests := []struct {
		helpArguments []string
		hideHelp      bool
		wantContains  string
		wantErr       error
	}{
		{
			helpArguments: []string{"boom", "--help"},
			hideHelp:      false,
			wantContains:  "boom - make an explosive entrance",
		},
		{
			helpArguments: []string{"boom", "-h"},
			hideHelp:      false,
			wantContains:  "boom - make an explosive entrance",
		},
		{
			helpArguments: []string{"boom", "help"},
			hideHelp:      false,
			wantContains:  "boom - make an explosive entrance",
		},
		{
			helpArguments: []string{"boom", "--help"},
			hideHelp:      true,
			wantErr:       fmt.Errorf("flag provided but not defined: -help"),
		},
		{
			helpArguments: []string{"boom", "-h"},
			hideHelp:      true,
			wantErr:       fmt.Errorf("flag provided but not defined: -h"),
		},
		{
			helpArguments: []string{"boom", "help"},
			hideHelp:      true,
			wantContains:  "boom I say!",
		},
	}

	for _, tt := range tests {
		t.Run(fmt.Sprintf("checking with arguments %v%v", tt.helpArguments, tt.hideHelp), func(t *testing.T) {
			buf := new(bytes.Buffer)

			cmd := &Command{
				Name:     "boom",
				Usage:    "make an explosive entrance",
				Writer:   buf,
				HideHelp: tt.hideHelp,
				Action: func(context.Context, *Command) error {
					buf.WriteString("boom I say!")
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), tt.helpArguments)
			if tt.wantErr != nil {
				assert.ErrorContains(t, err, tt.wantErr.Error())
			}

			output := buf.String()

			assert.Contains(t, output, tt.wantContains, "want help to contain %q, did not: \n%q", "boom - make an explosive entrance", output)
		})
	}
}

func TestCommand_Run_HelpFlagIgnoresNonCommandArguments(t *testing.T) {
	tests := []struct {
		args         []string
		wantContains string
	}{
		{
			args:         []string{"myCLI", "--help", "ciao"},
			wantContains: "myCLI - My Usage",
		},
		{
			args:         []string{"myCLI", "ciao", "-h"},
			wantContains: "myCLI - My Usage",
		},
		{
			args:         []string{"myCLI", "command", "ciao", "--help"},
			wantContains: "myCLI command - Show the version of My CLI",
		},
		{
			args:         []string{"myCLI", "command", "--help", "ciao"},
			wantContains: "myCLI command - Show the version of My CLI",
		},
	}

	for _, tt := range tests {
		t.Run(strings.Join(tt.args, " "), func(t *testing.T) {
			var buf bytes.Buffer

			cmd := &Command{
				Writer: &buf,
				Name:   "myCLI",
				Usage:  "My Usage",
				Commands: []*Command{
					{
						Name: "command",
						Arguments: []Argument{
							&StringArg{
								Name:      "arg1",
								UsageText: "ARG1",
							},
						},
						Usage: "Show the version of My CLI",
						Action: func(context.Context, *Command) error {
							return nil
						},
					},
				},
				Action: func(context.Context, *Command) error {
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), tt.args)
			require.NoError(t, err)
			require.Contains(t, buf.String(), tt.wantContains)
		})
	}
}

func TestCommand_Run_Version(t *testing.T) {
	versionArguments := [][]string{{"boom", "--version"}, {"boom", "-v"}}

	for _, args := range versionArguments {
		t.Run(fmt.Sprintf("checking with arguments %v", args), func(t *testing.T) {
			buf := new(bytes.Buffer)

			cmd := &Command{
				Name:    "boom",
				Usage:   "make an explosive entrance",
				Version: "0.1.0",
				Writer:  buf,
				Action: func(context.Context, *Command) error {
					buf.WriteString("boom I say!")
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), args)
			assert.NoError(t, err)
			assert.Contains(t, buf.String(), "0.1.0", "want version to contain 0.1.0")
		})
	}
}

func TestCommand_Run_CustomFlagCanUseVersionAlias(t *testing.T) {
	buf := new(bytes.Buffer)
	called := false

	cmd := &Command{
		Name:    "boom",
		Version: "0.1.0",
		Writer:  buf,
		Flags: []Flag{
			&BoolFlag{Name: "verbose", Aliases: []string{"v"}},
		},
		Action: func(_ context.Context, cmd *Command) error {
			called = true
			assert.True(t, cmd.Bool("verbose"))
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"boom", "-v"})

	assert.NoError(t, err)
	assert.True(t, called)
	assert.Empty(t, buf.String())
}

func TestCommand_Run_Categories(t *testing.T) {
	buf := new(bytes.Buffer)

	cmd := &Command{
		Name:     "categories",
		HideHelp: true,
		Commands: []*Command{
			{
				Name:     "command1",
				Category: "1",
			},
			{
				Name:     "command2",
				Category: "1",
			},
			{
				Name:     "command3",
				Category: "2",
			},
		},
		Writer: buf,
	}

	_ = cmd.Run(buildTestContext(t), []string{"categories"})

	expect := commandCategories([]*commandCategory{
		{
			name: "1",
			commands: []*Command{
				cmd.Commands[0],
				cmd.Commands[1],
			},
		},
		{
			name: "2",
			commands: []*Command{
				cmd.Commands[2],
			},
		},
	})

	require.Equal(t, &expect, cmd.categories)

	output := buf.String()

	assert.Contains(t, output, "1:\n     command1", "want buffer to include category %q, did not: \n%q", "1:\n     command1", output)
}

func TestCommand_VisibleCategories(t *testing.T) {
	cmd := &Command{
		Name:     "visible-categories",
		HideHelp: true,
		Commands: []*Command{
			{
				Name:     "command1",
				Category: "1",
				Hidden:   true,
			},
			{
				Name:     "command2",
				Category: "2",
			},
			{
				Name:     "command3",
				Category: "3",
			},
		},
	}

	expected := []CommandCategory{
		&commandCategory{
			name: "2",
			commands: []*Command{
				cmd.Commands[1],
			},
		},
		&commandCategory{
			name: "3",
			commands: []*Command{
				cmd.Commands[2],
			},
		},
	}

	cmd.setupDefaults([]string{"test"})
	assert.Equal(t, expected, cmd.VisibleCategories())

	cmd = &Command{
		Name:     "visible-categories",
		HideHelp: true,
		Commands: []*Command{
			{
				Name:     "command1",
				Category: "1",
				Hidden:   true,
			},
			{
				Name:     "command2",
				Category: "2",
				Hidden:   true,
			},
			{
				Name:     "command3",
				Category: "3",
			},
		},
	}

	expected = []CommandCategory{
		&commandCategory{
			name: "3",
			commands: []*Command{
				cmd.Commands[2],
			},
		},
	}

	cmd.setupDefaults([]string{"test"})
	assert.Equal(t, expected, cmd.VisibleCategories())

	cmd = &Command{
		Name:     "visible-categories",
		HideHelp: true,
		Commands: []*Command{
			{
				Name:     "command1",
				Category: "1",
				Hidden:   true,
			},
			{
				Name:     "command2",
				Category: "2",
				Hidden:   true,
			},
			{
				Name:     "command3",
				Category: "3",
				Hidden:   true,
			},
		},
	}

	cmd.setupDefaults([]string{"test"})
	assert.Empty(t, cmd.VisibleCategories())
}

func TestCommand_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
	cmd := &Command{
		Commands: []*Command{
			{
				Commands: []*Command{
					{
						Name: "sub",
					},
				},
				Name:   "bar",
				Before: func(context.Context, *Command) (context.Context, error) { return nil, fmt.Errorf("before error") },
				After:  func(context.Context, *Command) error { return fmt.Errorf("after error") },
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "bar"})
	assert.ErrorContains(t, err, "before error")
	assert.ErrorContains(t, err, "after error")
}

func TestCommand_OnUsageError_WithWrongFlagValue_ForSubcommand(t *testing.T) {
	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{Name: "flag"},
		},
		OnUsageError: func(_ context.Context, _ *Command, err error, isSubcommand bool) error {
			assert.False(t, isSubcommand, "Expect subcommand")
			assert.ErrorContains(t, err, "\"wrong\": invalid syntax")
			return errors.New("intercepted: " + err.Error())
		},
		Commands: []*Command{
			{
				Name: "bar",
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "--flag=wrong", "bar"})
	assert.ErrorContains(t, err, "parsing \"wrong\": invalid syntax", "Expect an intercepted error")
}

// A custom flag that conforms to the relevant interfaces, but has none of the
// fields that the other flag types do.
type customBoolFlag struct {
	Nombre string
}

// Don't use the normal FlagStringer
func (c *customBoolFlag) String() string {
	return "***" + c.Nombre + "***"
}

func (c *customBoolFlag) Names() []string {
	return []string{c.Nombre}
}

func (c *customBoolFlag) TakesValue() bool {
	return false
}

func (c *customBoolFlag) GetValue() string {
	return "value"
}

func (c *customBoolFlag) GetUsage() string {
	return "usage"
}

func (c *customBoolFlag) PreParse() error {
	return nil
}

func (c *customBoolFlag) PostParse() error {
	return nil
}

func (c *customBoolFlag) Get() any {
	dest := false
	return &boolValue{
		destination: &dest,
	}
}

func (c *customBoolFlag) Set(_, _ string) error {
	return nil
}

func (c *customBoolFlag) RunAction(context.Context, *Command) error {
	return nil
}

func (c *customBoolFlag) IsSet() bool {
	return false
}

func (c *customBoolFlag) IsRequired() bool {
	return false
}

func (c *customBoolFlag) IsVisible() bool {
	return false
}

func (c *customBoolFlag) GetCategory() string {
	return ""
}

func (c *customBoolFlag) GetEnvVars() []string {
	return nil
}

func (c *customBoolFlag) GetDefaultText() string {
	return ""
}

func TestCustomFlagsUnused(t *testing.T) {
	cmd := &Command{
		Flags:  []Flag{&customBoolFlag{"custom"}},
		Writer: io.Discard,
	}

	err := cmd.Run(buildTestContext(t), []string{"foo"})
	assert.NoError(t, err, "Run returned unexpected error")
}

func TestCustomFlagsUsed(t *testing.T) {
	cmd := &Command{
		Flags:  []Flag{&customBoolFlag{"custom"}},
		Writer: io.Discard,
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "--custom=bar"})
	assert.NoError(t, err, "Run returned unexpected error")
}

// Regression for #2229. When a user flag claims the -v alias, only that
// alias is yielded: --version must still print the version.
func TestVersionFlagWorksWhenAliasYieldedToUserFlag(t *testing.T) {
	buf := new(bytes.Buffer)
	called := false

	cmd := &Command{
		Name:    "boom",
		Version: "0.1.0",
		Writer:  buf,
		Flags: []Flag{
			&BoolFlag{Name: "verbose", Aliases: []string{"v"}},
		},
		Action: func(_ context.Context, _ *Command) error {
			called = true
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"boom", "--version"})

	assert.NoError(t, err)
	assert.False(t, called, "version should short-circuit the action")
	assert.Contains(t, buf.String(), "0.1.0")
}

func TestDropClashingAliases(t *testing.T) {
	verbose := &BoolFlag{Name: "verbose", Aliases: []string{"v"}}

	for _, tc := range []struct {
		name     string
		aliases  []string
		flags    []Flag
		selfName string
		want     []string
	}{
		{name: "no aliases", aliases: nil, flags: []Flag{verbose}, selfName: "version", want: nil},
		{name: "no flags", aliases: []string{"v"}, flags: nil, selfName: "version", want: []string{"v"}},
		{name: "drops clashing alias", aliases: []string{"v"}, flags: []Flag{verbose}, selfName: "version", want: []string{}},
		{name: "keeps free alias", aliases: []string{"V"}, flags: []Flag{verbose}, selfName: "version", want: []string{"V"}},
		{name: "keeps selfName even if claimed", aliases: []string{"verbose"}, flags: []Flag{verbose}, selfName: "verbose", want: []string{"verbose"}},
	} {
		t.Run(tc.name, func(t *testing.T) {
			assert.Equal(t, tc.want, dropClashingAliases(tc.aliases, tc.flags, tc.selfName))
		})
	}
}

func TestCustomHelpVersionFlags(t *testing.T) {
	cmd := &Command{
		Writer: io.Discard,
	}

	// Be sure to reset the global flags
	defer func(helpFlag Flag, versionFlag Flag) {
		HelpFlag = helpFlag.(*BoolFlag)
		VersionFlag = versionFlag.(*BoolFlag)
	}(HelpFlag, VersionFlag)

	HelpFlag = &customBoolFlag{"help-custom"}
	VersionFlag = &customBoolFlag{"version-custom"}

	err := cmd.Run(buildTestContext(t), []string{"foo", "--help-custom=bar"})
	assert.NoError(t, err, "Run returned unexpected error")
}

func TestHandleExitCoder_Default(t *testing.T) {
	app := buildMinimalTestCommand()
	_ = app.handleExitCoder(context.Background(), Exit("Default Behavior Error", 42))

	output := fakeErrWriter.String()
	assert.Contains(t, output, "Default", "Expected Default Behavior from Error Handler")
}

func TestHandleExitCoder_Custom(t *testing.T) {
	cmd := buildMinimalTestCommand()

	cmd.ExitErrHandler = func(context.Context, *Command, error) {
		_, _ = fmt.Fprintln(ErrWriter, "I'm a Custom error handler, I print what I want!")
	}

	_ = cmd.handleExitCoder(context.Background(), Exit("Default Behavior Error", 42))

	output := fakeErrWriter.String()
	assert.Contains(t, output, "Custom", "Expected Custom Behavior from Error Handler")
}

func TestShellCompletionForIncompleteFlags(t *testing.T) {
	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name: "test-completion",
			},
		},
		EnableShellCompletion: true,
		ShellComplete: func(_ context.Context, cmd *Command) {
			for _, command := range cmd.Commands {
				if command.Hidden {
					continue
				}

				for _, name := range command.Names() {
					_, _ = fmt.Fprintln(cmd.Writer, name)
				}
			}

			for _, fl := range cmd.Flags {
				for _, name := range fl.Names() {
					if name == GenerateShellCompletionFlag.Names()[0] {
						continue
					}

					switch name = strings.TrimSpace(name); len(name) {
					case 0:
					case 1:
						_, _ = fmt.Fprintln(cmd.Writer, "-"+name)
					default:
						_, _ = fmt.Fprintln(cmd.Writer, "--"+name)
					}
				}
			}
		},
		Action: func(context.Context, *Command) error {
			return fmt.Errorf("should not get here")
		},
		Writer: io.Discard,
	}

	err := cmd.Run(buildTestContext(t), []string{"", "--test-completion", completionFlag})
	assert.NoError(t, err, "app should not return an error")
}

func TestWhenExitSubCommandWithCodeThenCommandQuitUnexpectedly(t *testing.T) {
	testCode := 104

	cmd := buildMinimalTestCommand()
	cmd.Commands = []*Command{
		{
			Name: "cmd",
			Commands: []*Command{
				{
					Name: "subcmd",
					Action: func(context.Context, *Command) error {
						return Exit("exit error", testCode)
					},
				},
			},
		},
	}

	// set user function as ExitErrHandler
	exitCodeFromExitErrHandler := int(0)
	cmd.ExitErrHandler = func(_ context.Context, _ *Command, err error) {
		if exitErr, ok := err.(ExitCoder); ok {
			exitCodeFromExitErrHandler = exitErr.ExitCode()
		}
	}

	// keep and restore original OsExiter
	origExiter := OsExiter
	t.Cleanup(func() { OsExiter = origExiter })

	// set user function as OsExiter
	exitCodeFromOsExiter := int(0)
	OsExiter = func(exitCode int) {
		exitCodeFromOsExiter = exitCode
	}

	r := require.New(t)

	r.Error(cmd.Run(buildTestContext(t), []string{
		"myapp",
		"cmd",
		"subcmd",
	}))

	r.Equal(0, exitCodeFromOsExiter)
	r.Equal(testCode, exitCodeFromExitErrHandler)
}

func buildMinimalTestCommand() *Command {
	// reset the help flag because tests may have set it
	HelpFlag.(*BoolFlag).hasBeenSet = false
	return &Command{Writer: io.Discard}
}

func TestSetupInitializesBothWriters(t *testing.T) {
	cmd := &Command{}

	cmd.setupDefaults([]string{"test"})

	assert.Equal(t, cmd.ErrWriter, os.Stderr, "expected a.ErrWriter to be os.Stderr")
	assert.Equal(t, cmd.Writer, os.Stdout, "expected a.Writer to be os.Stdout")
}

func TestSetupInitializesOnlyNilWriters(t *testing.T) {
	wr := &bytes.Buffer{}
	cmd := &Command{
		ErrWriter: wr,
	}

	cmd.setupDefaults([]string{"test"})

	assert.Equal(t, cmd.ErrWriter, wr, "expected a.ErrWriter to be a *bytes.Buffer instance")
	assert.Equal(t, cmd.Writer, os.Stdout, "expected a.Writer to be os.Stdout")
}

// Regression for #2325. A Writer set on the root command should reach
// the subcommand's Action via c.Writer, not get silently replaced by
// os.Stdout the first time the subcommand runs setupDefaults.
func TestSubcommandInheritsRootWriters(t *testing.T) {
	var out, errOut bytes.Buffer
	root := &Command{
		Name:      "demo",
		Writer:    &out,
		ErrWriter: &errOut,
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(_ context.Context, c *Command) error {
					_, _ = fmt.Fprintln(c.Writer, "from sub")
					_, _ = fmt.Fprintln(c.ErrWriter, "errors from sub")
					return nil
				},
			},
		},
	}

	assert.NoError(t, root.Run(buildTestContext(t), []string{"demo", "sub"}))
	assert.Equal(t, "from sub\n", out.String())
	assert.Equal(t, "errors from sub\n", errOut.String())
}

func TestFlagAction(t *testing.T) {
	now := time.Now().UTC().Truncate(time.Minute)
	testCases := []struct {
		name string
		args []string
		err  string
		exp  string
	}{
		{
			name: "flag_string",
			args: []string{"app", "--f_string=string"},
			exp:  "string ",
		},
		{
			name: "flag_string_error",
			args: []string{"app", "--f_string="},
			err:  "empty string",
		},
		{
			name: "flag_string_error2",
			args: []string{"app", "--f_string=", "--f_bool"},
			err:  "empty string",
		},
		{
			name: "flag_string_slice",
			args: []string{"app", "--f_string_slice=s1,s2,s3"},
			exp:  "[s1 s2 s3] ",
		},
		{
			name: "flag_string_slice_error",
			args: []string{"app", "--f_string_slice=err"},
			err:  "error string slice",
		},
		{
			name: "flag_bool",
			args: []string{"app", "--f_bool"},
			exp:  "true ",
		},
		{
			name: "flag_bool_error",
			args: []string{"app", "--f_bool=false"},
			err:  "value is false",
		},
		{
			name: "flag_duration",
			args: []string{"app", "--f_duration=1h30m20s"},
			exp:  "1h30m20s ",
		},
		{
			name: "flag_duration_error",
			args: []string{"app", "--f_duration=0"},
			err:  "empty duration",
		},
		{
			name: "flag_float64",
			args: []string{"app", "--f_float64=3.14159"},
			exp:  "3.14159 ",
		},
		{
			name: "flag_float64_error",
			args: []string{"app", "--f_float64=-1"},
			err:  "negative float64",
		},
		{
			name: "flag_float64_slice",
			args: []string{"app", "--f_float64_slice=1.1,2.2,3.3"},
			exp:  "[1.1 2.2 3.3] ",
		},
		{
			name: "flag_float64_slice_error",
			args: []string{"app", "--f_float64_slice=-1"},
			err:  "invalid float64 slice",
		},
		{
			name: "flag_int",
			args: []string{"app", "--f_int=1"},
			exp:  "1 ",
		},
		{
			name: "flag_int_error",
			args: []string{"app", "--f_int=-1"},
			err:  "negative int",
		},
		{
			name: "flag_int_slice",
			args: []string{"app", "--f_int_slice=1,2,3"},
			exp:  "[1 2 3] ",
		},
		{
			name: "flag_int_slice_error",
			args: []string{"app", "--f_int_slice=-1"},
			err:  "invalid int slice",
		},
		{
			name: "flag_timestamp",
			args: []string{"app", "--f_timestamp", now.Format(time.DateTime)},
			exp:  now.UTC().Format(time.RFC3339) + " ",
		},
		{
			name: "flag_timestamp_error",
			args: []string{"app", "--f_timestamp", "0001-01-01 00:00:00"},
			err:  "zero timestamp",
		},
		{
			name: "flag_uint",
			args: []string{"app", "--f_uint=1"},
			exp:  "1 ",
		},
		{
			name: "flag_uint_error",
			args: []string{"app", "--f_uint=0"},
			err:  "zero uint64",
		},
		{
			name: "flag_no_action",
			args: []string{"app", "--f_no_action=xx"},
			exp:  "",
		},
		{
			name: "command_flag",
			args: []string{"app", "c1", "--f_string=c1"},
			exp:  "c1 ",
		},
		{
			name: "subCommand_flag",
			args: []string{"app", "c1", "sub1", "--f_string=sub1"},
			exp:  "sub1 ",
		},
		// TBD
		/*		{
				name: "mixture",
				args: []string{"app", "--f_string=app", "--f_uint=1", "--f_int_slice=1,2,3", "--f_duration=1h30m20s", "c1", "--f_string=c1", "sub1", "--f_string=sub1"},
				exp:  "app 1 [1 2 3] 1h30m20s c1 sub1 ",
			},*/
		{
			name: "flag_string_map",
			args: []string{"app", "--f_string_map=s1=s2,s3="},
			exp:  "map[s1:s2 s3:]",
		},
		{
			name: "flag_string_map_error",
			args: []string{"app", "--f_string_map=err="},
			err:  "error string map",
		},
	}

	for _, test := range testCases {
		t.Run(test.name, func(t *testing.T) {
			out := &bytes.Buffer{}

			newStringFlag := func(local bool) *StringFlag {
				return &StringFlag{
					Local: local,
					Name:  "f_string",
					Action: func(_ context.Context, cmd *Command, v string) error {
						if v == "" {
							return fmt.Errorf("empty string")
						}
						_, err := cmd.Root().Writer.Write([]byte(v + " "))
						return err
					},
				}
			}

			cmd := &Command{
				Writer: out,
				Name:   "app",
				Commands: []*Command{
					{
						Name:   "c1",
						Flags:  []Flag{newStringFlag(true)},
						Action: func(_ context.Context, cmd *Command) error { return nil },
						Commands: []*Command{
							{
								Name:   "sub1",
								Action: func(context.Context, *Command) error { return nil },
								Flags:  []Flag{newStringFlag(true)},
							},
						},
					},
				},
				Flags: []Flag{
					newStringFlag(true),
					&StringFlag{
						Name: "f_no_action",
					},
					&StringSliceFlag{
						Local: true,
						Name:  "f_string_slice",
						Action: func(_ context.Context, cmd *Command, v []string) error {
							if v[0] == "err" {
								return fmt.Errorf("error string slice")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v ", v)
							return err
						},
					},
					&BoolFlag{
						Name:  "f_bool",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v bool) error {
							if !v {
								return fmt.Errorf("value is false")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%t ", v)
							return err
						},
					},
					&DurationFlag{
						Name:  "f_duration",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v time.Duration) error {
							if v == 0 {
								return fmt.Errorf("empty duration")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, v.String()+" ")
							return err
						},
					},
					&FloatFlag{
						Name:  "f_float64",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v float64) error {
							if v < 0 {
								return fmt.Errorf("negative float64")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, strconv.FormatFloat(v, 'f', -1, 64)+" ")
							return err
						},
					},
					&FloatSliceFlag{
						Name:  "f_float64_slice",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v []float64) error {
							if len(v) > 0 && v[0] < 0 {
								return fmt.Errorf("invalid float64 slice")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v ", v)
							return err
						},
					},
					&Int64Flag{
						Name:  "f_int",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v int64) error {
							if v < 0 {
								return fmt.Errorf("negative int")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v ", v)
							return err
						},
					},
					&Int64SliceFlag{
						Name:  "f_int_slice",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v []int64) error {
							if len(v) > 0 && v[0] < 0 {
								return fmt.Errorf("invalid int slice")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v ", v)
							return err
						},
					},
					&TimestampFlag{
						Name:  "f_timestamp",
						Local: true,
						Config: TimestampConfig{
							Timezone: time.UTC,
							Layouts:  []string{time.DateTime},
						},
						Action: func(_ context.Context, cmd *Command, v time.Time) error {
							if v.IsZero() {
								return fmt.Errorf("zero timestamp")
							}

							_, err := cmd.Root().Writer.Write([]byte(v.Format(time.RFC3339) + " "))
							return err
						},
					},
					&Uint64Flag{
						Name:  "f_uint",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v uint64) error {
							if v == 0 {
								return fmt.Errorf("zero uint64")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v ", v)
							return err
						},
					},
					&StringMapFlag{
						Name:  "f_string_map",
						Local: true,
						Action: func(_ context.Context, cmd *Command, v map[string]string) error {
							if _, ok := v["err"]; ok {
								return fmt.Errorf("error string map")
							}
							_, err := fmt.Fprintf(cmd.Root().Writer, "%v", v)
							return err
						},
					},
				},
				Action: func(context.Context, *Command) error { return nil },
			}

			err := cmd.Run(buildTestContext(t), test.args)

			r := require.New(t)

			if test.err != "" {
				r.EqualError(err, test.err)
				return
			}

			r.NoError(err)
			r.Equal(test.exp, out.String())
		})
	}
}

func TestLocalSliceFlagAccumulation(t *testing.T) {
	var got []string

	app := &Command{
		Name: "app",
		Commands: []*Command{
			{
				Name: "sub",
				Flags: []Flag{
					&StringSliceFlag{
						Name:        "paths",
						Aliases:     []string{"p"},
						Local:       true,
						Destination: &got,
					},
				},
				Action: func(_ context.Context, cmd *Command) error {
					return nil
				},
			},
		},
	}

	err := app.Run(context.Background(), []string{"app", "sub", "-p", "/a", "-p", "/b", "-p", "/c"})
	if err != nil {
		t.Fatal(err)
	}

	if len(got) != 3 {
		t.Errorf("expected 3 values, got %d: %v", len(got), got)
	}
}

func TestLocalFlagError(t *testing.T) {
	var topInt int64

	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name:        "cmdFlag",
				Destination: &topInt,
				Local:       true,
			},
		},
		Commands: []*Command{
			{
				Name: "subcmd",
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{
		"app",
		"subcmd",
		"--cmdFlag", "11",
	})

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "flag provided but not defined: -cmdFlag")
}

func TestPersistentFlag(t *testing.T) {
	var topInt, topPersistentInt, subCommandInt, appOverrideInt int64
	var appFlag string
	var appRequiredFlag string
	var appOverrideCmdInt int64
	var appSliceFloat64 []float64
	var persistentCommandSliceInt []int64
	var persistentFlagActionCount int64

	cmd := &Command{
		Flags: []Flag{
			&StringFlag{
				Name:        "persistentCommandFlag",
				Destination: &appFlag,
				Action: func(context.Context, *Command, string) error {
					persistentFlagActionCount++
					return nil
				},
			},
			&Int64SliceFlag{
				Name:        "persistentCommandSliceFlag",
				Destination: &persistentCommandSliceInt,
			},
			&FloatSliceFlag{
				Name:  "persistentCommandFloatSliceFlag",
				Value: []float64{11.3, 12.5},
			},
			&Int64Flag{
				Name:        "persistentCommandOverrideFlag",
				Destination: &appOverrideInt,
			},
			&StringFlag{
				Name:        "persistentRequiredCommandFlag",
				Required:    true,
				Destination: &appRequiredFlag,
			},
		},
		Commands: []*Command{
			{
				Name: "cmd",
				Flags: []Flag{
					&Int64Flag{
						Name:        "cmdFlag",
						Destination: &topInt,
						Local:       true,
					},
					&Int64Flag{
						Name:        "cmdPersistentFlag",
						Destination: &topPersistentInt,
					},
					&Int64Flag{
						Name:        "paof",
						Aliases:     []string{"persistentCommandOverrideFlag"},
						Destination: &appOverrideCmdInt,
						Local:       true,
					},
				},
				Commands: []*Command{
					{
						Name: "subcmd",
						Flags: []Flag{
							&Int64Flag{
								Name:        "cmdFlag",
								Destination: &subCommandInt,
								Local:       true,
							},
						},
						Action: func(_ context.Context, cmd *Command) error {
							appSliceFloat64 = cmd.FloatSlice("persistentCommandFloatSliceFlag")
							return nil
						},
					},
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{
		"app",
		"--persistentCommandFlag", "hello",
		"--persistentCommandSliceFlag", "100",
		"--persistentCommandOverrideFlag", "102",
		"cmd",
		"--cmdFlag", "12",
		"--persistentCommandSliceFlag", "102",
		"--persistentCommandFloatSliceFlag", "102.455",
		"--paof", "105",
		"--persistentRequiredCommandFlag", "hellor",
		"subcmd",
		"--cmdPersistentFlag", "20",
		"--cmdFlag", "11",
		"--persistentCommandFlag", "bar",
		"--persistentCommandSliceFlag", "130",
		"--persistentCommandFloatSliceFlag", "3.1445",
	})

	require.NoError(t, err)

	assert.Equal(t, "bar", appFlag)
	assert.Equal(t, "hellor", appRequiredFlag)
	assert.Equal(t, int64(12), topInt)
	assert.Equal(t, int64(20), topPersistentInt)

	// this should be changed from app since
	// cmd overrides it
	assert.Equal(t, int64(102), appOverrideInt)
	assert.Equal(t, int64(11), subCommandInt)
	assert.Equal(t, int64(105), appOverrideCmdInt)
	assert.Equal(t, []int64{100, 102, 130}, persistentCommandSliceInt)
	assert.Equal(t, []float64{102.455, 3.1445}, appSliceFloat64)
	assert.Equal(t, int64(2), persistentFlagActionCount, "Expected persistent flag action to be called 2 times")
}

func TestPersistentFlagIsSet(t *testing.T) {
	result := ""
	resultIsSet := false

	app := &Command{
		Name: "root",
		Flags: []Flag{
			&StringFlag{
				Name: "result",
			},
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(_ context.Context, cmd *Command) error {
					result = cmd.String("result")
					resultIsSet = cmd.IsSet("result")
					return nil
				},
			},
		},
	}

	err := app.Run(context.Background(), []string{"root", "--result", "before", "sub"})
	require.NoError(t, err)
	require.Equal(t, "before", result)
	require.True(t, resultIsSet)

	err = app.Run(context.Background(), []string{"root", "sub", "--result", "after"})
	require.NoError(t, err)
	require.Equal(t, "after", result)
	require.True(t, resultIsSet)
}

func TestDuplicatePersistentFlagUsesEnvSource(t *testing.T) {
	t.Setenv("APP_RESULT", "from-env")

	resultFlag := &StringFlag{
		Name:     "result",
		Sources:  EnvVars("APP_RESULT"),
		Required: true,
	}

	var beforeResult string
	var actionResult string
	app := &Command{
		Name: "root",
		Flags: []Flag{
			resultFlag,
		},
		Before: func(_ context.Context, cmd *Command) (context.Context, error) {
			beforeResult = cmd.String("result")
			return nil, nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				Flags: []Flag{
					resultFlag,
				},
				Action: func(_ context.Context, cmd *Command) error {
					actionResult = cmd.String("result")
					return nil
				},
			},
		},
	}

	err := app.Run(context.Background(), []string{"root", "sub"})
	require.NoError(t, err)
	require.Equal(t, "from-env", beforeResult)
	require.Equal(t, "from-env", actionResult)
	require.True(t, app.IsSet("result"))
	require.True(t, app.Command("sub").IsSet("result"))
}

func TestPersistentFlagCommandLineOverridesSourceInSubcommand(t *testing.T) {
	tests := []struct {
		name  string
		env   string
		flag  func() Flag
		args  []string
		value func(*Command) any
		want  any
	}{
		{
			name:  "string slice",
			env:   "a,b",
			flag:  func() Flag { return &StringSliceFlag{Name: "tags", Sources: EnvVars("APP_VALUE")} },
			args:  []string{"--tags", "c"},
			value: func(cmd *Command) any { return cmd.StringSlice("tags") },
			want:  []string{"c"},
		},
		{
			name:  "string map",
			env:   "a=1",
			flag:  func() Flag { return &StringMapFlag{Name: "labels", Sources: EnvVars("APP_VALUE")} },
			args:  []string{"--labels", "b=2"},
			value: func(cmd *Command) any { return cmd.StringMap("labels") },
			want:  map[string]string{"b": "2"},
		},
		{
			name:  "only once",
			env:   "from-env",
			flag:  func() Flag { return &StringFlag{Name: "name", Sources: EnvVars("APP_VALUE"), OnlyOnce: true} },
			args:  []string{"--name", "from-cli"},
			value: func(cmd *Command) any { return cmd.String("name") },
			want:  "from-cli",
		},
		{
			name:  "bool with inverse",
			env:   "true",
			flag:  func() Flag { return &BoolWithInverseFlag{Name: "color", Sources: EnvVars("APP_VALUE")} },
			args:  []string{"--no-color"},
			value: func(cmd *Command) any { return cmd.Bool("color") },
			want:  false,
		},
	}

	for _, test := range tests {
		for _, where := range []string{"root", "sub"} {
			t.Run(test.name+" on "+where, func(t *testing.T) {
				t.Setenv("APP_VALUE", test.env)

				var got any
				cmd := &Command{
					Name:  "root",
					Flags: []Flag{test.flag()},
					Commands: []*Command{
						{
							Name: "sub",
							Action: func(_ context.Context, cmd *Command) error {
								got = test.value(cmd)
								return nil
							},
						},
					},
				}

				args := append([]string{"root"}, test.args...)
				args = append(args, "sub")
				if where == "sub" {
					args = append([]string{"root", "sub"}, test.args...)
				}

				require.NoError(t, cmd.Run(buildTestContext(t), args))
				assert.Equal(t, test.want, got)
			})
		}
	}
}

func TestPersistentFlagSourceResetKeepsSliceSeparator(t *testing.T) {
	t.Setenv("APP_VALUE", "a;b")

	var got []string
	cmd := &Command{
		Name:  "root",
		Flags: []Flag{&StringSliceFlag{Name: "tags", Sources: EnvVars("APP_VALUE")}},
		Commands: []*Command{
			{
				Name:               "sub",
				SliceFlagSeparator: ";",
				Action: func(_ context.Context, cmd *Command) error {
					got = cmd.StringSlice("tags")
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"root", "sub", "--tags", "c;d"}))
	assert.Equal(t, []string{"c", "d"}, got)
}

func TestRequiredFlagDelayed(t *testing.T) {
	sf := &StringFlag{
		Name:     "result",
		Required: true,
	}

	expectedErr := &errRequiredFlags{
		missingFlags: []string{sf.Name},
	}

	tests := []struct {
		name        string
		args        []string
		errExpected error
	}{
		{
			name:        "leaf help",
			args:        []string{"root", "sub", "-h"},
			errExpected: nil,
		},
		{
			name:        "leaf action",
			args:        []string{"root", "sub"},
			errExpected: expectedErr,
		},
		{
			name:        "leaf flags set",
			args:        []string{"root", "sub", "--if", "10"},
			errExpected: expectedErr,
		},
		{
			name:        "leaf invalid flags set",
			args:        []string{"root", "sub", "--xx"},
			errExpected: expectedErr,
		},
	}

	app := &Command{
		Name: "root",
		Flags: []Flag{
			sf,
		},
		Commands: []*Command{
			{
				Name: "sub",
				Flags: []Flag{
					&Int64Flag{
						Name:     "if",
						Required: true,
					},
				},
				Action: func(ctx context.Context, c *Command) error {
					return nil
				},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			err := app.Run(context.Background(), test.args)
			if test.errExpected == nil {
				require.NoError(t, err)
			} else {
				require.ErrorAs(t, err, &test.errExpected)
			}
		})
	}
}

func TestRequiredPersistentFlag(t *testing.T) {
	app := &Command{
		Name: "root",
		Flags: []Flag{
			&StringFlag{
				Name:     "result",
				Required: true,
			},
		},
		Commands: []*Command{
			{
				Name: "sub",
				Action: func(ctx context.Context, c *Command) error {
					return nil
				},
			},
		},
	}

	err := app.Run(context.Background(), []string{"root", "sub"})
	require.Error(t, err)

	err = app.Run(context.Background(), []string{"root", "sub", "--result", "after"})
	require.NoError(t, err)
}

func TestFlagDuplicates(t *testing.T) {
	tests := []struct {
		name        string
		args        []string
		errExpected bool
	}{
		{
			name: "all args present once",
			args: []string{"foo", "--sflag", "hello", "--isflag", "1", "--isflag", "2", "--fsflag", "2.0", "--iflag", "10", "--bifflag"},
		},
		{
			name: "duplicate non slice flag(duplicatable)",
			args: []string{"foo", "--sflag", "hello", "--isflag", "1", "--isflag", "2", "--fsflag", "2.0", "--iflag", "10", "--iflag", "20"},
		},
		{
			name:        "duplicate non slice flag(non duplicatable)",
			args:        []string{"foo", "--sflag", "hello", "--isflag", "1", "--isflag", "2", "--fsflag", "2.0", "--iflag", "10", "--sflag", "trip"},
			errExpected: true,
		},
		{
			name:        "duplicate slice flag(non duplicatable)",
			args:        []string{"foo", "--sflag", "hello", "--isflag", "1", "--isflag", "2", "--fsflag", "2.0", "--fsflag", "3.0", "--iflag", "10"},
			errExpected: true,
		},
		{
			name:        "duplicate bool inverse flag(non duplicatable)",
			args:        []string{"foo", "--bifflag", "--bifflag"},
			errExpected: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cmd := &Command{
				Flags: []Flag{
					&StringFlag{
						Name:     "sflag",
						OnlyOnce: true,
					},
					&Int64SliceFlag{
						Name: "isflag",
					},
					&FloatSliceFlag{
						Name:     "fsflag",
						OnlyOnce: true,
					},
					&BoolWithInverseFlag{
						Name:     "bifflag",
						OnlyOnce: true,
					},
					&Int64Flag{
						Name: "iflag",
					},
				},
				Action: func(context.Context, *Command) error {
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			if test.errExpected {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestDuplicateFlagNamesAreRejected(t *testing.T) {
	tests := []struct {
		name                   string
		flags                  []Flag
		mutuallyExclusiveFlags []MutuallyExclusiveFlags
	}{
		{
			name: "duplicate flag names",
			flags: []Flag{
				&BoolFlag{Name: "config"},
				&StringFlag{Name: "config"},
			},
		},
		{
			name: "duplicate flag aliases",
			flags: []Flag{
				&BoolFlag{Name: "verbose", Aliases: []string{"v"}},
				&StringFlag{Name: "value", Aliases: []string{"v"}},
			},
		},
		{
			name: "flag and mutually exclusive flag",
			flags: []Flag{
				&StringFlag{Name: "config"},
			},
			mutuallyExclusiveFlags: []MutuallyExclusiveFlags{{
				Flags: [][]Flag{
					{&BoolFlag{Name: "config"}},
					{&BoolFlag{Name: "other"}},
				},
			}},
		},
		{
			name: "mutually exclusive flags",
			mutuallyExclusiveFlags: []MutuallyExclusiveFlags{{
				Flags: [][]Flag{
					{&BoolFlag{Name: "config"}},
					{&StringFlag{Name: "config"}},
				},
			}},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cmd := &Command{
				Flags:                  test.flags,
				MutuallyExclusiveFlags: test.mutuallyExclusiveFlags,
				Action: func(context.Context, *Command) error {
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), []string{"foo"})
			require.Error(t, err)
			require.Contains(t, err.Error(), "defined multiple times")
		})
	}
}

// Duplicates in a subcommand are reported on any run, not only when that
// subcommand runs.
func TestDuplicateFlagNamesInSubcommandAreRejected(t *testing.T) {
	tests := []struct {
		name string
		args []string
	}{
		{name: "root", args: []string{"foo"}},
		{name: "root help flag", args: []string{"foo", "--help"}},
		{name: "subcommand", args: []string{"foo", "sub"}},
		{name: "subcommand help flag", args: []string{"foo", "sub", "--help"}},
		{name: "help command", args: []string{"foo", "help", "sub"}},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cmd := &Command{
				Writer: io.Discard,
				Commands: []*Command{
					{
						Name: "sub",
						Flags: []Flag{
							&BoolFlag{Name: "help"},
							&BoolFlag{Name: "help"},
						},
					},
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			require.EqualError(t, err, `flag "help" defined multiple times in command "foo sub"`)
		})
	}
}

// A Go flag that another package registers on flag.CommandLine, such as
// glog's -v, can't be renamed by the user, so it is not reported as a
// duplicate. The user flag wins, as before.
func TestDuplicateFlagNamesSkipExtFlags(t *testing.T) {
	origCommandLine := flag.CommandLine
	t.Cleanup(func() { flag.CommandLine = origCommandLine })
	flag.CommandLine = flag.NewFlagSet("foo", flag.ContinueOnError)
	ext := flag.Bool("v", false, "ext package flag usage")

	cmd := &Command{
		AllowExtFlags: true,
		Flags: []Flag{
			&BoolFlag{Name: "verbose", Aliases: []string{"v"}},
		},
		Action: func(context.Context, *Command) error {
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "-v"})
	require.NoError(t, err)
	require.True(t, cmd.Bool("verbose"))
	require.False(t, *ext)
}

func TestUserDefinedHelpFlagOverridesBuiltin(t *testing.T) {
	writer := &bytes.Buffer{}
	cmd := &Command{
		Writer: writer,
		Flags: []Flag{
			&BoolFlag{Name: "help", Usage: "custom help behavior"},
		},
		Action: func(context.Context, *Command) error {
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "--help"})
	require.NoError(t, err)
	require.True(t, cmd.Bool("help"))

	var helpFlags int
	for _, fl := range cmd.Flags {
		if slices.Contains(fl.Names(), "help") {
			helpFlags++
		}
	}
	require.Equal(t, 1, helpFlags)
	require.Contains(t, writer.String(), "--help  custom help behavior")
	require.NotContains(t, writer.String(), "--help, -h  show help")
}

// When a user flag claims the -h alias, only that alias is yielded: -h
// goes to the user flag and --help must still show help.
func TestHelpFlagWorksWhenAliasYieldedToUserFlag(t *testing.T) {
	tests := []struct {
		name       string
		flag       Flag
		args       []string
		wantCalled bool
		wantValue  any
	}{
		{
			name:      "long help",
			flag:      &StringFlag{Name: "h", Usage: "host"},
			args:      []string{"foo", "--help"},
			wantValue: "",
		},
		{
			name:       "user short flag",
			flag:       &StringFlag{Name: "h", Usage: "host"},
			args:       []string{"foo", "-h", "example.com"},
			wantCalled: true,
			wantValue:  "example.com",
		},
		{
			name:       "user short bool flag",
			flag:       &BoolFlag{Name: "h", Usage: "human readable"},
			args:       []string{"foo", "-h"},
			wantCalled: true,
			wantValue:  true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			writer := &bytes.Buffer{}
			called := false

			cmd := &Command{
				Writer: writer,
				Flags:  []Flag{test.flag},
				Action: func(context.Context, *Command) error {
					called = true
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			require.NoError(t, err)
			require.Equal(t, test.wantCalled, called)
			require.Equal(t, test.wantValue, cmd.Value("h"))
			if !test.wantCalled {
				require.Contains(t, writer.String(), "show help")
				require.NotContains(t, writer.String(), "--help, -h")
			}
		})
	}
}

// When a user command claims the h alias, only that alias is yielded: h runs
// the user command, help still shows help, and the help listing no longer
// advertises h for the help command.
func TestHelpCommandYieldsAliasToUserCommand(t *testing.T) {
	tests := []struct {
		name        string
		args        []string
		wantHistory bool
	}{
		{name: "user alias", args: []string{"app", "h"}, wantHistory: true},
		{name: "help command", args: []string{"app", "help"}},
		{name: "help flag", args: []string{"app", "--help"}},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			out := &bytes.Buffer{}
			ranHistory := false

			cmd := &Command{
				Name:   "app",
				Writer: out,
				Commands: []*Command{
					{
						Name:    "history",
						Aliases: []string{"h"},
						Usage:   "show history",
						Action: func(context.Context, *Command) error {
							ranHistory = true
							return nil
						},
					},
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			require.NoError(t, err)
			assert.Equal(t, test.wantHistory, ranHistory)
			if !test.wantHistory {
				assert.Contains(t, out.String(), "history, h")
				assert.Regexp(t, `(?m)^\s+help\s+Shows a list of commands`, out.String())
				assert.NotContains(t, out.String(), "help, h")
			}
		})
	}
}

// A user flag that takes the name of the help flag, such as HelpFlag
// itself listed in Flags, still shows help instead of running the action.
func TestHelpFlagNameTakenByUserFlag(t *testing.T) {
	origHelpFlag := HelpFlag
	t.Cleanup(func() { HelpFlag = origHelpFlag })
	helpFlag := *origHelpFlag.(*BoolFlag)
	HelpFlag = &helpFlag

	tests := []struct {
		name     string
		hideHelp bool
		flag     Flag
		args     []string
	}{
		{
			name: "HelpFlag listed",
			flag: HelpFlag,
			args: []string{"foo", "--help"},
		},
		{
			name: "HelpFlag listed in subcommand",
			flag: HelpFlag,
			args: []string{"foo", "sub", "--help"},
		},
		{
			name: "HelpFlag listed in subcommand, short",
			flag: HelpFlag,
			args: []string{"foo", "sub", "-h"},
		},
		{
			name:     "HideHelp and user help flag",
			hideHelp: true,
			flag:     &BoolFlag{Name: "help"},
			args:     []string{"foo", "--help"},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			writer := &bytes.Buffer{}
			called := false
			action := func(context.Context, *Command) error {
				called = true
				return nil
			}

			cmd := &Command{
				Writer:   writer,
				HideHelp: test.hideHelp,
				Flags:    []Flag{test.flag},
				Action:   action,
				Commands: []*Command{
					{
						Name:   "sub",
						Flags:  []Flag{test.flag},
						Action: action,
					},
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			require.NoError(t, err)
			require.False(t, called, "help should short-circuit the action")
			require.Contains(t, writer.String(), "USAGE:")
		})
	}
}

func TestShorthandCommand(t *testing.T) {
	af := func(p *int) ActionFunc {
		return func(context.Context, *Command) error {
			*p = *p + 1
			return nil
		}
	}

	var cmd1, cmd2 int

	cmd := &Command{
		PrefixMatchCommands: true,
		Commands: []*Command{
			{
				Name:    "cthdisd",
				Aliases: []string{"cth"},
				Action:  af(&cmd1),
			},
			{
				Name:    "cthertoop",
				Aliases: []string{"cer"},
				Action:  af(&cmd2),
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"foo", "cth"})
	assert.NoError(t, err)
	assert.True(t, cmd1 == 1 && cmd2 == 0, "Expected command1 to be triggered once")

	cmd1 = 0
	cmd2 = 0

	err = cmd.Run(buildTestContext(t), []string{"foo", "cthd"})
	assert.NoError(t, err)
	assert.True(t, cmd1 == 1 && cmd2 == 0, "Expected command1 to be triggered once")

	cmd1 = 0
	cmd2 = 0

	err = cmd.Run(buildTestContext(t), []string{"foo", "cthe"})
	assert.NoError(t, err)
	assert.True(t, cmd1 == 1 && cmd2 == 0, "Expected command1 to be triggered once")

	cmd1 = 0
	cmd2 = 0

	err = cmd.Run(buildTestContext(t), []string{"foo", "cthert"})
	assert.NoError(t, err)
	assert.True(t, cmd1 == 0 && cmd2 == 1, "Expected command1 to be triggered once")

	cmd1 = 0
	cmd2 = 0

	err = cmd.Run(buildTestContext(t), []string{"foo", "cthet"})
	assert.NoError(t, err)
	assert.True(t, cmd1 == 0 && cmd2 == 1, "Expected command1 to be triggered once")
}

func TestCommand_Int(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name:  "myflag",
				Value: 12,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name:  "top-flag",
				Value: 13,
			},
		},
		parent: pCmd,
	}

	require.Equal(t, int64(12), cmd.Int64("myflag"))
	require.Equal(t, int64(13), cmd.Int64("top-flag"))
}

func TestCommand_Uint(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&Uint64Flag{
				Name:  "myflagUint",
				Value: 13,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&Uint64Flag{
				Name:  "top-flag",
				Value: 14,
			},
		},
		parent: pCmd,
	}

	require.Equal(t, uint64(13), cmd.Uint64("myflagUint"))
	require.Equal(t, uint64(14), cmd.Uint64("top-flag"))
}

func TestCommand_Float64(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&FloatFlag{
				Name:  "myflag",
				Value: 17,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&FloatFlag{
				Name:  "top-flag",
				Value: 18,
			},
		},
		parent: pCmd,
	}

	r := require.New(t)
	r.Equal(float64(17), cmd.Float("myflag"))
	r.Equal(float64(18), cmd.Float("top-flag"))
}

func TestCommand_Duration(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&DurationFlag{
				Name:  "myflag",
				Value: 12 * time.Second,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&DurationFlag{
				Name:  "top-flag",
				Value: 13 * time.Second,
			},
		},
		parent: pCmd,
	}

	r := require.New(t)
	r.Equal(12*time.Second, cmd.Duration("myflag"))
	r.Equal(13*time.Second, cmd.Duration("top-flag"))
}

func TestCommand_Timestamp(t *testing.T) {
	t1 := time.Time{}.Add(12 * time.Second)
	t2 := time.Time{}.Add(13 * time.Second)

	cmd := &Command{
		Name: "hello",
		Flags: []Flag{
			&TimestampFlag{
				Name:  "myflag",
				Value: t1,
			},
		},
		Action: func(ctx context.Context, c *Command) error {
			return nil
		},
	}

	pCmd := &Command{
		Flags: []Flag{
			&TimestampFlag{
				Name:  "top-flag",
				Value: t2,
			},
		},
		Commands: []*Command{
			cmd,
		},
	}

	err := pCmd.Run(context.Background(), []string{"foo", "hello"})
	assert.NoError(t, err)

	r := require.New(t)
	r.Equal(t1, cmd.Timestamp("myflag"))
	r.Equal(t2, cmd.Timestamp("top-flag"))
}

func TestCommand_String(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&StringFlag{
				Name:  "myflag",
				Value: "hello world",
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&StringFlag{
				Name:  "top-flag",
				Value: "hai veld",
			},
		},
		parent: pCmd,
	}

	r := require.New(t)
	r.Equal("hello world", cmd.String("myflag"))
	r.Equal("hai veld", cmd.String("top-flag"))

	r.Equal("hai veld", cmd.String("top-flag"))
}

func TestCommand_Bool(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name: "myflag",
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name:  "top-flag",
				Value: true,
			},
		},
		parent: pCmd,
	}

	r := require.New(t)
	r.False(cmd.Bool("myflag"))
	r.True(cmd.Bool("top-flag"))
}

func TestCommand_Value(t *testing.T) {
	subCmd := &Command{
		Name: "test",
		Flags: []Flag{
			&Int64Flag{
				Name:    "myflag",
				Usage:   "doc",
				Aliases: []string{"m", "mf"},
			},
		},
		Action: func(ctx context.Context, c *Command) error {
			return nil
		},
	}

	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name:    "top-flag",
				Usage:   "doc",
				Aliases: []string{"t", "tf"},
			},
		},
		Commands: []*Command{
			subCmd,
		},
	}
	t.Run("flag name", func(t *testing.T) {
		r := require.New(t)
		err := cmd.Run(buildTestContext(t), []string{"main", "--top-flag", "13", "test", "--myflag", "14"})

		r.NoError(err)
		r.Equal(int64(13), cmd.Value("top-flag"))
		r.Equal(int64(13), cmd.Value("t"))
		r.Equal(int64(13), cmd.Value("tf"))

		r.Equal(int64(14), subCmd.Value("myflag"))
		r.Equal(int64(14), subCmd.Value("m"))
		r.Equal(int64(14), subCmd.Value("mf"))
	})

	t.Run("flag aliases", func(t *testing.T) {
		r := require.New(t)
		err := cmd.Run(buildTestContext(t), []string{"main", "-tf", "15", "test", "-m", "16"})

		r.NoError(err)
		r.Equal(int64(15), cmd.Value("top-flag"))
		r.Equal(int64(15), cmd.Value("t"))
		r.Equal(int64(15), cmd.Value("tf"))

		r.Equal(int64(16), subCmd.Value("myflag"))
		r.Equal(int64(16), subCmd.Value("m"))
		r.Equal(int64(16), subCmd.Value("mf"))
		r.Nil(cmd.Value("unknown-flag"))
	})
}

func TestCommand_Value_InvalidFlagAccessHandler(t *testing.T) {
	var flagName string
	cmd := &Command{
		InvalidFlagAccessHandler: func(_ context.Context, _ *Command, name string) {
			flagName = name
		},
		Commands: []*Command{
			{
				Name: "command",
				Commands: []*Command{
					{
						Name: "subcommand",
						Action: func(_ context.Context, cmd *Command) error {
							cmd.Value("missing")
							return nil
						},
					},
				},
			},
		},
	}

	r := require.New(t)

	r.NoError(cmd.Run(buildTestContext(t), []string{"run", "command", "subcommand"}))
	r.Equal("missing", flagName)
}

func TestCommand_Args(t *testing.T) {
	cmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name: "myflag",
			},
		},
	}
	_ = cmd.Run(context.Background(), []string{"", "--myflag", "bat", "baz"})

	r := require.New(t)
	r.Equal(2, cmd.Args().Len())
	r.True(cmd.Bool("myflag"))
	r.Equal(2, cmd.NArg())
}

func TestCommand_IsSet(t *testing.T) {
	cmd := &Command{
		Name: "frob",
		Flags: []Flag{
			&BoolFlag{
				Name: "one-flag",
			},
			&BoolFlag{
				Name: "two-flag",
			},
			&StringFlag{
				Name:  "three-flag",
				Value: "hello world",
			},
		},
	}
	pCmd := &Command{
		Name: "root",
		Flags: []Flag{
			&BoolFlag{
				Name:  "top-flag",
				Value: true,
			},
		},
		Commands: []*Command{
			cmd,
		},
	}

	r := require.New(t)

	r.NoError(pCmd.Run(context.Background(), []string{"foo", "frob", "--one-flag", "--top-flag", "--two-flag", "--three-flag", "dds"}))

	r.True(cmd.IsSet("one-flag"))
	r.True(cmd.IsSet("two-flag"))
	r.True(cmd.IsSet("three-flag"))
	r.True(cmd.IsSet("top-flag"))
	r.False(cmd.IsSet("bogus"))
}

// XXX Corresponds to hack in context.IsSet for flags with EnvVar field
// Should be moved to `flag_test` in v2
func TestCommand_IsSet_fromEnv(t *testing.T) {
	var (
		timeoutIsSet, tIsSet    bool
		noEnvVarIsSet, nIsSet   bool
		passwordIsSet, pIsSet   bool
		unparsableIsSet, uIsSet bool
	)

	t.Setenv("APP_TIMEOUT_SECONDS", "15.5")
	t.Setenv("APP_PASSWORD", "")

	cmd := &Command{
		Flags: []Flag{
			&FloatFlag{Name: "timeout", Aliases: []string{"t"}, Local: true, Sources: EnvVars("APP_TIMEOUT_SECONDS")},
			&StringFlag{Name: "password", Aliases: []string{"p"}, Local: true, Sources: EnvVars("APP_PASSWORD")},
			&FloatFlag{Name: "unparsable", Aliases: []string{"u"}, Local: true, Sources: EnvVars("APP_UNPARSABLE")},
			&FloatFlag{Name: "no-env-var", Aliases: []string{"n"}, Local: true},
		},
		Action: func(_ context.Context, cmd *Command) error {
			timeoutIsSet = cmd.IsSet("timeout")
			tIsSet = cmd.IsSet("t")
			passwordIsSet = cmd.IsSet("password")
			pIsSet = cmd.IsSet("p")
			unparsableIsSet = cmd.IsSet("unparsable")
			uIsSet = cmd.IsSet("u")
			noEnvVarIsSet = cmd.IsSet("no-env-var")
			nIsSet = cmd.IsSet("n")
			return nil
		},
	}

	r := require.New(t)

	r.NoError(cmd.Run(buildTestContext(t), []string{"run"}))
	r.True(timeoutIsSet)
	r.True(tIsSet)
	r.True(passwordIsSet)
	r.True(pIsSet)
	r.False(noEnvVarIsSet)
	r.False(nIsSet)

	t.Setenv("APP_UNPARSABLE", "foobar")

	r.Error(cmd.Run(buildTestContext(t), []string{"run"}))
	r.False(unparsableIsSet)
	r.False(uIsSet)
}

func TestCommand_NumFlags(t *testing.T) {
	rootCmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name:  "myflagGlobal",
				Value: true,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name: "myflag",
			},
			&StringFlag{
				Name:  "otherflag",
				Value: "hello world",
			},
		},
	}

	_ = cmd.Run(context.Background(), []string{"", "--myflag", "--otherflag=foo"})
	_ = rootCmd.Run(context.Background(), []string{"", "--myflagGlobal"})
	require.Equal(t, 2, cmd.NumFlags())
	actualFlags := cmd.LocalFlagNames()
	sort.Strings(actualFlags)

	require.Equal(t, []string{"myflag", "otherflag"}, actualFlags)

	actualFlags = cmd.FlagNames()
	sort.Strings(actualFlags)

	require.Equal(t, []string{"myflag", "otherflag"}, actualFlags)

	cmd.parent = rootCmd
	lineage := cmd.Lineage()

	r := require.New(t)
	r.Equal(2, len(lineage))
	r.Equal(cmd, lineage[0])
	r.Equal(rootCmd, lineage[1])
}

func TestCommand_Set(t *testing.T) {
	cmd := &Command{
		Flags: []Flag{
			&Int64Flag{
				Name:  "int",
				Value: 5,
			},
		},
	}
	r := require.New(t)

	r.False(cmd.IsSet("int"))
	r.NoError(cmd.Set("int", "1"))
	r.Equal(int64(1), cmd.Int64("int"))
	r.True(cmd.IsSet("int"))
}

func TestCommand_Set_ReplacesSourceValue(t *testing.T) {
	t.Setenv("APP_VALUE", "a,b")

	var got []string
	cmd := &Command{
		Name:  "root",
		Flags: []Flag{&StringSliceFlag{Name: "tags", Sources: EnvVars("APP_VALUE")}},
		Before: func(ctx context.Context, cmd *Command) (context.Context, error) {
			return ctx, cmd.Set("tags", "c")
		},
		Action: func(_ context.Context, cmd *Command) error {
			got = cmd.StringSlice("tags")
			return nil
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"root"}))
	assert.Equal(t, []string{"c"}, got)
}

func TestCommand_Set_InvalidFlagAccessHandler(t *testing.T) {
	var flagName string
	cmd := &Command{
		InvalidFlagAccessHandler: func(_ context.Context, _ *Command, name string) {
			flagName = name
		},
	}

	r := require.New(t)

	r.True(cmd.Set("missing", "") != nil)
	r.Equal("missing", flagName)
}

func TestCommand_lookupFlag(t *testing.T) {
	pCmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name:  "top-flag",
				Value: true,
			},
		},
	}
	cmd := &Command{
		Flags: []Flag{
			&BoolFlag{
				Name: "local-flag",
			},
		},
	}
	_ = cmd.Run(context.Background(), []string{"--local-flag"})
	pCmd.Commands = []*Command{cmd}
	_ = pCmd.Run(context.Background(), []string{"--top-flag"})

	r := require.New(t)

	fs := cmd.lookupFlag("top-flag")
	r.Equal(pCmd.Flags[0], fs)

	fs = cmd.lookupFlag("local-flag")
	r.Equal(cmd.Flags[0], fs)
	r.Nil(cmd.lookupFlag("frob"))
}

func TestCommandAttributeAccessing(t *testing.T) {
	tdata := []struct {
		testCase     string
		setBoolInput string
		ctxBoolInput string
		parent       *Command
	}{
		{
			testCase:     "empty",
			setBoolInput: "",
			ctxBoolInput: "",
		},
		{
			testCase:     "empty_with_background_context",
			setBoolInput: "",
			ctxBoolInput: "",
			parent:       &Command{},
		},
		{
			testCase:     "empty_set_bool_and_present_ctx_bool",
			setBoolInput: "",
			ctxBoolInput: "ctx-bool",
		},
		{
			testCase:     "present_set_bool_and_present_ctx_bool_with_background_context",
			setBoolInput: "",
			ctxBoolInput: "ctx-bool",
			parent:       &Command{},
		},
		{
			testCase:     "present_set_bool_and_present_ctx_bool",
			setBoolInput: "ctx-bool",
			ctxBoolInput: "ctx-bool",
		},
		{
			testCase:     "present_set_bool_and_present_ctx_bool_with_background_context",
			setBoolInput: "ctx-bool",
			ctxBoolInput: "ctx-bool",
			parent:       &Command{},
		},
		{
			testCase:     "present_set_bool_and_different_ctx_bool",
			setBoolInput: "ctx-bool",
			ctxBoolInput: "not-ctx-bool",
		},
		{
			testCase:     "present_set_bool_and_different_ctx_bool_with_background_context",
			setBoolInput: "ctx-bool",
			ctxBoolInput: "not-ctx-bool",
			parent:       &Command{},
		},
	}

	for _, test := range tdata {
		t.Run(test.testCase, func(t *testing.T) {
			cmd := &Command{parent: test.parent}

			require.False(t, cmd.Bool(test.ctxBoolInput))
		})
	}
}

func TestCheckRequiredFlags(t *testing.T) {
	tdata := []struct {
		testCase              string
		parseInput            []string
		envVarInput           [2]string
		flags                 []Flag
		expectedAnError       bool
		expectedErrorContents []string
	}{
		{
			testCase: "empty",
		},
		{
			testCase: "optional",
			flags: []Flag{
				&StringFlag{Name: "optionalFlag"},
			},
		},
		{
			testCase: "required",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
			},
			expectedAnError:       true,
			expectedErrorContents: []string{"requiredFlag"},
		},
		{
			testCase: "required_and_present",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
			},
			parseInput: []string{"--requiredFlag", "myinput"},
		},
		{
			testCase: "required_and_present_via_env_var",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true, Sources: EnvVars("REQUIRED_FLAG")},
			},
			envVarInput: [2]string{"REQUIRED_FLAG", "true"},
		},
		{
			testCase: "required_and_optional",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "optionalFlag"},
			},
			expectedAnError: true,
		},
		{
			testCase: "required_and_optional_and_optional_present",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "optionalFlag"},
			},
			parseInput:      []string{"--optionalFlag", "myinput"},
			expectedAnError: true,
		},
		{
			testCase: "required_and_optional_and_optional_present_via_env_var",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "optionalFlag", Sources: EnvVars("OPTIONAL_FLAG")},
			},
			envVarInput:     [2]string{"OPTIONAL_FLAG", "true"},
			expectedAnError: true,
		},
		{
			testCase: "required_and_optional_and_required_present",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "optionalFlag"},
			},
			parseInput: []string{"--requiredFlag", "myinput"},
		},
		{
			testCase: "two_required",
			flags: []Flag{
				&StringFlag{Name: "requiredFlagOne", Required: true},
				&StringFlag{Name: "requiredFlagTwo", Required: true},
			},
			expectedAnError:       true,
			expectedErrorContents: []string{"requiredFlagOne", "requiredFlagTwo"},
		},
		{
			testCase: "two_required_and_one_present",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "requiredFlagTwo", Required: true},
			},
			parseInput:      []string{"--requiredFlag", "myinput"},
			expectedAnError: true,
		},
		{
			testCase: "two_required_and_both_present",
			flags: []Flag{
				&StringFlag{Name: "requiredFlag", Required: true},
				&StringFlag{Name: "requiredFlagTwo", Required: true},
			},
			parseInput: []string{"--requiredFlag", "myinput", "--requiredFlagTwo", "myinput"},
		},
		{
			testCase: "required_flag_with_short_name",
			flags: []Flag{
				&StringSliceFlag{Name: "names", Aliases: []string{"N"}, Required: true},
			},
			parseInput: []string{"-N", "asd", "-N", "qwe"},
		},
		{
			testCase: "required_flag_with_multiple_short_names",
			flags: []Flag{
				&StringSliceFlag{Name: "names", Aliases: []string{"N", "n"}, Required: true},
			},
			parseInput: []string{"-n", "asd", "-n", "qwe"},
		},
		{
			testCase:              "required_flag_with_short_alias_not_printed_on_error",
			expectedAnError:       true,
			expectedErrorContents: []string{"Required flag \"names\" not set"},
			flags: []Flag{
				&StringSliceFlag{Name: "names", Aliases: []string{"n"}, Required: true},
			},
		},
		{
			testCase:              "required_flag_with_one_character",
			expectedAnError:       true,
			expectedErrorContents: []string{"Required flag \"n\" not set"},
			flags: []Flag{
				&StringFlag{Name: "n", Required: true},
			},
		},
	}

	for _, test := range tdata {
		t.Run(test.testCase, func(t *testing.T) {
			// setup
			if test.envVarInput[0] != "" {
				t.Setenv(test.envVarInput[0], test.envVarInput[1])
			}

			cmd := &Command{
				Name:  "foo",
				Flags: test.flags,
			}
			args := []string{"foo"}
			args = append(args, test.parseInput...)
			_ = cmd.Run(context.Background(), args)

			err := cmd.checkAllRequiredFlags()

			// assertions
			if test.expectedAnError {
				assert.NotNil(t, err)
			} else {
				assert.Nil(t, err)
			}
			for _, errString := range test.expectedErrorContents {
				if err != nil {
					assert.ErrorContains(t, err, errString)
				}
			}
		})
	}
}

func TestCheckRequiredFlagsWithOnUsageError(t *testing.T) {
	expectedError := errors.New("OnUsageError")
	cmd := &Command{
		Name: "foo",
		Flags: []Flag{
			&StringFlag{Name: "requiredFlag", Required: true},
		},
		OnUsageError: func(_ context.Context, _ *Command, _ error, _ bool) error {
			return expectedError
		},
	}
	actualError := cmd.Run(buildTestContext(t), []string{"requiredFlag"})
	require.ErrorIs(t, actualError, expectedError)
}

func TestCommand_ParentCommand_Set(t *testing.T) {
	cmd := &Command{
		parent: &Command{
			Flags: []Flag{
				&StringFlag{
					Name: "Name",
				},
			},
		},
	}

	err := cmd.Set("Name", "aaa")
	assert.NoError(t, err)
}

func TestCommandStringDashOption(t *testing.T) {
	tests := []struct {
		name                string
		shortOptionHandling bool
		args                []string
	}{
		{
			name: "double dash separate value",
			args: []string{"foo", "--bar", "-", "test"},
		},
		{
			name: "single dash separate value",
			args: []string{"foo", "-bar", "-", "test"},
		},
		/*{
			name:                "single dash combined value",
			args:                []string{"foo", "-b-", "test"},
			shortOptionHandling: true,
		},*/
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cmd := &Command{
				Name:                   "foo",
				UseShortOptionHandling: test.shortOptionHandling,
				Flags: []Flag{
					&StringFlag{
						Name:    "bar",
						Aliases: []string{"b"},
					},
				},
				Action: func(ctx context.Context, c *Command) error {
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), test.args)
			assert.NoError(t, err)

			assert.Equal(t, "-", cmd.String("b"))
		})
	}
}

func TestCommandReadArgsFromStdinPositionalArgs(t *testing.T) {
	tests := []struct {
		name  string
		input string
		args  []string
		want  []string
	}{
		{name: "empty", want: []string{}},
		{name: "whitespace", input: " \t\r\n\u2003", want: []string{}},
		{name: "token at EOF", input: "file.txt", want: []string{"file.txt"}},
		{name: "trailing newline", input: "file.txt\n", want: []string{"file.txt"}},
		{name: "trailing whitespace", input: "file.txt \t\r\n\u2003", want: []string{"file.txt"}},
		{name: "multiple lines", input: "first.txt\nsecond.txt\n", want: []string{"first.txt", "second.txt"}},
		{name: "quoted token", input: `"file name.txt"`, want: []string{"file name.txt"}},
		{name: "quoted whitespace", input: `" "`, want: []string{" "}},
		{name: "unclosed quote", input: `"file name.txt`, want: []string{"file name.txt"}},
		{name: "unclosed quoted whitespace", input: `" `, want: []string{}},
		// Empty quoted stdin strings are currently ignored by the tokenizer.
		{name: "empty quotes before token", input: `"" file.txt`, want: []string{"file.txt"}},
		{name: "stdin terminator at EOF", input: "file.txt --", want: []string{"file.txt"}},
		{name: "stdin terminator", input: "file.txt --\nignored.txt\n", want: []string{"file.txt"}},
		{name: "empty command line argument", input: "file.txt\n", args: []string{"", "last.txt"}, want: []string{"", "last.txt", "file.txt"}},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			actionCalled := false
			cmd := &Command{
				Name:              "app",
				Reader:            strings.NewReader(test.input),
				ReadArgsFromStdin: true,
				Action: func(_ context.Context, c *Command) error {
					actionCalled = true
					require.Equal(t, test.want, c.Args().Slice())
					return nil
				},
			}
			require.NoError(t, cmd.Run(context.Background(), append([]string{"app"}, test.args...)))
			require.True(t, actionCalled)
		})
	}
}

func TestCommandReadArgsFromStdinReadError(t *testing.T) {
	readErr := errors.New("stdin read failed")
	for _, input := range []string{"", "file.txt", "file.txt\n"} {
		t.Run(input, func(t *testing.T) {
			actionCalled := false
			cmd := &Command{
				Name:              "app",
				Reader:            io.MultiReader(strings.NewReader(input), iotest.ErrReader(readErr)),
				ReadArgsFromStdin: true,
				Action: func(_ context.Context, _ *Command) error {
					actionCalled = true
					return nil
				},
			}
			require.ErrorIs(t, cmd.Run(context.Background(), []string{"app"}), readErr)
			require.False(t, actionCalled)
		})
	}
}

func TestCommandReadArgsFromStdIn(t *testing.T) {
	tests := []struct {
		name          string
		input         string
		args          []string
		expectedInt   int64
		expectedFloat float64
		expectedSlice []string
		expectError   bool
	}{
		{
			name:          "empty",
			input:         "",
			args:          []string{"foo"},
			expectedInt:   0,
			expectedFloat: 0.0,
			expectedSlice: []string{},
		},
		{
			name: "empty2",
			input: `

			`,
			args:          []string{"foo"},
			expectedInt:   0,
			expectedFloat: 0.0,
			expectedSlice: []string{},
		},
		{
			name:          "intflag-from-input",
			input:         "--if=100",
			args:          []string{"foo"},
			expectedInt:   100,
			expectedFloat: 0.0,
			expectedSlice: []string{},
		},
		{
			name: "intflag-from-input2",
			input: `
			--if

			100`,
			args:          []string{"foo"},
			expectedInt:   100,
			expectedFloat: 0.0,
			expectedSlice: []string{},
		},
		{
			name: "multiflag-from-input",
			input: `
			--if

			100
			--ff      100.1

			--ssf hello
			--ssf

			"hello
  123
44"
			`,
			args:          []string{"foo"},
			expectedInt:   100,
			expectedFloat: 100.1,
			expectedSlice: []string{"hello", "hello\n  123\n44"},
		},
		{
			name: "end-args",
			input: `
			--if

			100
			--
			--ff      100.1

			--ssf hello
			--ssf

			hell02
			`,
			args:          []string{"foo"},
			expectedInt:   100,
			expectedFloat: 0,
			expectedSlice: []string{},
		},
		{
			name: "invalid string",
			input: `
			"
			`,
			args:          []string{"foo"},
			expectedInt:   0,
			expectedFloat: 0,
			expectedSlice: []string{},
		},
		{
			name: "invalid string2",
			input: `
			--if
			"
			`,
			args:        []string{"foo"},
			expectError: true,
		},
		{
			name: "incomplete string",
			input: `
			--ssf
			"
			hello
			`,
			args:          []string{"foo"},
			expectedSlice: []string{"hello"},
		},
	}

	for _, tst := range tests {
		t.Run(tst.name, func(t *testing.T) {
			r := require.New(t)

			fp, err := os.CreateTemp("", "readargs")
			r.NoError(err)
			_, err = fp.Write([]byte(tst.input))
			r.NoError(err)
			fp.Close()

			cmd := buildMinimalTestCommand()
			cmd.ReadArgsFromStdin = true
			cmd.Reader, err = os.Open(fp.Name())
			r.NoError(err)
			cmd.Flags = []Flag{
				&Int64Flag{
					Name: "if",
				},
				&FloatFlag{
					Name: "ff",
				},
				&StringSliceFlag{
					Name: "ssf",
					Config: StringConfig{
						TrimSpace: true,
					},
				},
			}

			actionCalled := false
			cmd.Action = func(ctx context.Context, c *Command) error {
				r.Equal(tst.expectedInt, c.Int64("if"))
				r.Equal(tst.expectedFloat, c.Float("ff"))
				r.Equal(tst.expectedSlice, c.StringSlice("ssf"))
				actionCalled = true
				return nil
			}

			err = cmd.Run(context.Background(), tst.args)
			if !tst.expectError {
				r.NoError(err)
				r.True(actionCalled)
			} else {
				r.Error(err)
			}
		})
	}
}

func TestZeroValueCommand(t *testing.T) {
	var cmd Command
	assert.NoError(t, cmd.Run(context.Background(), []string{"foo"}))
}

func TestCommandInvalidName(t *testing.T) {
	var cmd Command
	assert.Equal(t, int64(0), cmd.Int64("foo"))
	assert.Equal(t, uint64(0), cmd.Uint64("foo"))
	assert.Equal(t, float64(0), cmd.Float("foo"))
	assert.Equal(t, "", cmd.String("foo"))
	assert.Equal(t, time.Time{}, cmd.Timestamp("foo"))
	assert.Equal(t, time.Duration(0), cmd.Duration("foo"))

	assert.Equal(t, []int64(nil), cmd.Int64Slice("foo"))
	assert.Equal(t, []uint64(nil), cmd.Uint64Slice("foo"))
	assert.Equal(t, []float64(nil), cmd.FloatSlice("foo"))
	assert.Equal(t, []string(nil), cmd.StringSlice("foo"))
}

func TestCommandCategories(t *testing.T) {
	var cc commandCategories = []*commandCategory{
		{
			name:     "foo",
			commands: []*Command{},
		},
		{
			name:     "bar",
			commands: []*Command{},
		},
		{
			name:     "goo",
			commands: nil,
		},
	}

	sort.Sort(&cc)

	var prev *commandCategory
	for _, c := range cc {
		if prev != nil {
			assert.LessOrEqual(t, prev.name, c.name)
		}
		prev = c
		assert.Equal(t, []*Command(nil), c.VisibleCommands())
	}
}

func TestCommandSliceFlagSeparator(t *testing.T) {
	cmd := &Command{
		SliceFlagSeparator: ";",
		Flags: []Flag{
			&StringSliceFlag{
				Name: "foo",
			},
		},
	}

	r := require.New(t)
	r.NoError(cmd.Run(buildTestContext(t), []string{"app", "--foo", "ff;dd;gg", "--foo", "t,u"}))
	r.Equal([]string{"ff", "dd", "gg", "t,u"}, cmd.Value("foo"))
}

func TestCommandSliceFlagSeparatorFromEnvVar(t *testing.T) {
	t.Setenv("APP_FOO", "0 1 2")

	cmd := &Command{
		SliceFlagSeparator: " ",
		Flags: []Flag{
			&StringSliceFlag{
				Name:    "foo",
				Sources: EnvVars("APP_FOO"),
			},
		},
	}

	r := require.New(t)
	r.NoError(cmd.Run(buildTestContext(t), []string{"app"}))
	r.Equal([]string{"0", "1", "2"}, cmd.Value("foo"))
}

// A command that does not set SliceFlagSeparator uses the separator of its
// nearest ancestor that sets one, wherever --foo is defined and wherever its
// value comes from. DisableSliceFlagSeparator is not inherited.
func TestCommandSliceFlagSeparatorInheritance(t *testing.T) {
	tests := []struct {
		name        string
		rootSep     string
		rootDisable bool
		subSep      string
		subDisable  bool
		flagOn      string      // command that defines --foo: root, sub or leaf
		flag        func() Flag // --foo, a StringSliceFlag if nil
		env         string      // value of APP_FOO
		set         string      // value the Action passes to cmd.Set
		args        []string
		want        any
	}{
		{
			name:    "sub flag",
			rootSep: ";",
			flagOn:  "sub",
			args:    []string{"root", "sub", "--foo", "a;b,c"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "sub int slice flag",
			rootSep: ";",
			flagOn:  "sub",
			flag:    func() Flag { return &IntSliceFlag{Name: "foo"} },
			args:    []string{"root", "sub", "--foo", "1;2"},
			want:    []int{1, 2},
		},
		{
			name:    "sub map flag",
			rootSep: ";",
			flagOn:  "sub",
			flag:    func() Flag { return &StringMapFlag{Name: "foo"} },
			args:    []string{"root", "sub", "--foo", "a=1,2;b=3"},
			want:    map[string]string{"a": "1,2", "b": "3"},
		},
		{
			name:    "root flag before sub",
			rootSep: ";",
			flagOn:  "root",
			args:    []string{"root", "--foo", "a;b,c", "sub"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "root flag after sub",
			rootSep: ";",
			flagOn:  "root",
			args:    []string{"root", "sub", "--foo", "a;b,c"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "leaf flag",
			rootSep: ";",
			flagOn:  "leaf",
			args:    []string{"root", "sub", "leaf", "--foo", "a;b,c"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "sub flag from env",
			rootSep: ";",
			flagOn:  "sub",
			flag:    func() Flag { return &StringSliceFlag{Name: "foo", Sources: EnvVars("APP_FOO")} },
			env:     "a;b,c",
			args:    []string{"root", "sub"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "sub flag from cmd.Set",
			rootSep: ";",
			flagOn:  "sub",
			set:     "a;b,c",
			args:    []string{"root", "sub"},
			want:    []string{"a", "b,c"},
		},
		{
			name:    "sub separator wins",
			rootSep: ";",
			subSep:  "|",
			flagOn:  "sub",
			args:    []string{"root", "sub", "--foo", "a|b;c"},
			want:    []string{"a", "b;c"},
		},
		{
			name:    "nearest ancestor wins",
			rootSep: ";",
			subSep:  "|",
			flagOn:  "leaf",
			args:    []string{"root", "sub", "leaf", "--foo", "a|b;c"},
			want:    []string{"a", "b;c"},
		},
		{
			name:    "sub sets the default back",
			rootSep: ";",
			subSep:  ",",
			flagOn:  "sub",
			args:    []string{"root", "sub", "--foo", "a;b,c"},
			want:    []string{"a;b", "c"},
		},
		// DisableSliceFlagSeparator stays per command (#1856). These rows pin
		// today's behaviour: it applies to the values its command parses,
		// including an ancestor's flag given after its name, and subcommands
		// do not inherit it.
		{
			name:       "sub disable",
			rootSep:    ";",
			subDisable: true,
			flagOn:     "sub",
			args:       []string{"root", "sub", "--foo", "a;b,c"},
			want:       []string{"a;b,c"},
		},
		{
			name:       "sub disable, root flag after sub",
			rootSep:    ";",
			subDisable: true,
			flagOn:     "root",
			args:       []string{"root", "sub", "--foo", "a;b,c"},
			want:       []string{"a;b,c"},
		},
		{
			name:        "root disable, root flag before sub",
			rootDisable: true,
			flagOn:      "root",
			args:        []string{"root", "--foo", "a,b", "sub"},
			want:        []string{"a,b"},
		},
		{
			name:        "root disable, root flag after sub",
			rootDisable: true,
			flagOn:      "root",
			args:        []string{"root", "sub", "--foo", "a,b"},
			want:        []string{"a", "b"},
		},
		// Disable is not inherited, but the separator still is, as in v3.5.0.
		{
			name:       "sub disable, leaf flag",
			rootSep:    ";",
			subDisable: true,
			flagOn:     "leaf",
			args:       []string{"root", "sub", "leaf", "--foo", "a;b,c"},
			want:       []string{"a", "b,c"},
		},
		{
			name:        "root disable and separator, sub flag",
			rootSep:     ";",
			rootDisable: true,
			flagOn:      "sub",
			args:        []string{"root", "sub", "--foo", "a;b,c"},
			want:        []string{"a", "b,c"},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			if test.env != "" {
				t.Setenv("APP_FOO", test.env)
			}

			var got any
			action := func(_ context.Context, cmd *Command) error {
				if test.set != "" {
					if err := cmd.Set("foo", test.set); err != nil {
						return err
					}
				}
				got = cmd.Value("foo")
				return nil
			}

			leaf := &Command{Name: "leaf", Action: action}
			sub := &Command{
				Name:                      "sub",
				SliceFlagSeparator:        test.subSep,
				DisableSliceFlagSeparator: test.subDisable,
				Commands:                  []*Command{leaf},
				Action:                    action,
			}
			root := &Command{
				Name:                      "root",
				SliceFlagSeparator:        test.rootSep,
				DisableSliceFlagSeparator: test.rootDisable,
				Commands:                  []*Command{sub},
			}

			var foo Flag = &StringSliceFlag{Name: "foo"}
			if test.flag != nil {
				foo = test.flag()
			}
			owner := map[string]*Command{"root": root, "sub": sub, "leaf": leaf}[test.flagOn]
			owner.Flags = []Flag{foo}

			r := require.New(t)
			r.NoError(root.Run(buildTestContext(t), test.args))
			r.Equal(test.want, got)
		})
	}
}

// A command that does not set MapFlagKeyValueSeparator uses the separator of
// its nearest ancestor that sets one, as with SliceFlagSeparator.
func TestCommandMapFlagKeyValueSeparatorInheritance(t *testing.T) {
	tests := []struct {
		name         string
		rootSliceSep string
		rootSep      string
		subSep       string
		flagOn       string // command that defines --foo: root, sub or leaf
		args         []string
		want         map[string]string
	}{
		{
			name:    "sub flag",
			rootSep: ":",
			flagOn:  "sub",
			args:    []string{"root", "sub", "--foo", "a:1=2"},
			want:    map[string]string{"a": "1=2"},
		},
		{
			name:    "root flag after sub",
			rootSep: ":",
			flagOn:  "root",
			args:    []string{"root", "sub", "--foo", "a:1=2"},
			want:    map[string]string{"a": "1=2"},
		},
		{
			name:    "leaf flag",
			rootSep: ":",
			flagOn:  "leaf",
			args:    []string{"root", "sub", "leaf", "--foo", "a:1=2"},
			want:    map[string]string{"a": "1=2"},
		},
		{
			name:    "nearest ancestor wins",
			rootSep: ":",
			subSep:  "@",
			flagOn:  "leaf",
			args:    []string{"root", "sub", "leaf", "--foo", "a@1:2"},
			want:    map[string]string{"a": "1:2"},
		},
		{
			name:    "sub sets the default back",
			rootSep: ":",
			subSep:  "=",
			flagOn:  "sub",
			args:    []string{"root", "sub", "--foo", "a=1:2"},
			want:    map[string]string{"a": "1:2"},
		},
		{
			name:         "with root SliceFlagSeparator",
			rootSliceSep: ";",
			rootSep:      ":",
			flagOn:       "sub",
			args:         []string{"root", "sub", "--foo", "a:1;b:2"},
			want:         map[string]string{"a": "1", "b": "2"},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			var got any
			action := func(_ context.Context, cmd *Command) error {
				got = cmd.Value("foo")
				return nil
			}

			leaf := &Command{Name: "leaf", Action: action}
			sub := &Command{
				Name:                     "sub",
				MapFlagKeyValueSeparator: test.subSep,
				Commands:                 []*Command{leaf},
				Action:                   action,
			}
			root := &Command{
				Name:                     "root",
				SliceFlagSeparator:       test.rootSliceSep,
				MapFlagKeyValueSeparator: test.rootSep,
				Commands:                 []*Command{sub},
			}

			owner := map[string]*Command{"root": root, "sub": sub, "leaf": leaf}[test.flagOn]
			owner.Flags = []Flag{&StringMapFlag{Name: "foo"}}

			r := require.New(t)
			r.NoError(root.Run(buildTestContext(t), test.args))
			r.Equal(test.want, got)
		})
	}
}

func TestCommandMapKeyValueFlagSeparator(t *testing.T) {
	cmd := &Command{
		MapFlagKeyValueSeparator: ":",
		Flags: []Flag{
			&StringMapFlag{
				Name: "f_string_map",
			},
		},
	}

	r := require.New(t)
	r.NoError(cmd.Run(buildTestContext(t), []string{"app", "--f_string_map", "s1:s2,s3:", "--f_string_map", "s4:s5"}))
	exp := map[string]string{
		"s1": "s2",
		"s3": "",
		"s4": "s5",
	}
	r.Equal(exp, cmd.Value("f_string_map"))
}

// TestStringFlagTerminator tests the string flag "--flag" with "--" terminator.
func TestStringFlagTerminator(t *testing.T) {
	tests := []struct {
		name         string
		input        []string
		expectFlag   string
		expectArgs   []string
		expectErr    bool
		errorContain string
	}{
		{
			name:       "flag and args after terminator",
			input:      []string{"test", "--flag", "x", "--", "test", "a1", "a2", "a3"},
			expectFlag: "x",
			expectArgs: []string{"test", "a1", "a2", "a3"},
		},
		/*	{
			name:         "missing flag value due to terminator",
			input:        []string{"test", "--flag", "--", "x"},
			expectErr:    true,
			errorContain: "flag needs an argument",
		},*/
		{
			name:       "terminator with no trailing args",
			input:      []string{"test", "--flag", "x", "--"},
			expectFlag: "x",
			expectArgs: []string{},
		},
		{
			name:       "no terminator, only flag",
			input:      []string{"test", "--flag", "x"},
			expectFlag: "x",
			expectArgs: []string{},
		},
		{
			name:       "flag defined after --",
			input:      []string{"test", "--", "x", "--flag=value"},
			expectFlag: "",
			expectArgs: []string{"x", "--flag=value"},
		},
		{
			name:       "flag and without --",
			input:      []string{"test", "--flag", "value", "x"},
			expectFlag: "value",
			expectArgs: []string{"x"},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			var flagVal string
			var argsVal []string

			// build minimal command with a StringFlag "flag"
			cmd := &Command{
				Name: "test",
				Flags: []Flag{
					&StringFlag{
						Name:        "flag",
						Usage:       "a string flag",
						Destination: &flagVal,
					},
				},
				Action: func(ctx context.Context, c *Command) error {
					argsVal = c.Args().Slice()
					return nil
				},
			}

			err := cmd.Run(context.Background(), tc.input)
			if tc.expectErr {
				assert.Error(t, err)
				if err != nil {
					assert.Contains(t, strings.ToLower(err.Error()), strings.ToLower(tc.errorContain))
				}
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tc.expectFlag, flagVal)
				assert.Equal(t, tc.expectArgs, argsVal)
			}
		})
	}
}

// TestBoolFlagTerminator tests the bool flag
func TestBoolFlagTerminator(t *testing.T) {
	tests := []struct {
		name         string
		input        []string
		expectFlag   bool
		expectArgs   []string
		expectErr    bool
		errorContain string
	}{
		/*{
			name:         "bool flag with invalid non-bool value",
			input:        []string{"test", "--flag", "x", "--", "test", "a1", "a2", "a3"},
			expectErr:    true,
			errorContain: "invalid syntax",
		},*/
		{
			name:       "bool flag omitted value defaults to true",
			input:      []string{"test", "--flag", "--", "x"},
			expectFlag: true,
			expectArgs: []string{"x"},
		},
		{
			name:       "bool flag explicitly set to false",
			input:      []string{"test", "--flag=false", "--", "x"},
			expectFlag: false,
			expectArgs: []string{"x"},
		},
		{
			name:       "bool flag defined after --",
			input:      []string{"test", "--", "x", "--flag=true"},
			expectFlag: false,
			expectArgs: []string{"x", "--flag=true"},
		},
		{
			name:       "bool flag and without --",
			input:      []string{"test", "--flag=true", "x"},
			expectFlag: true,
			expectArgs: []string{"x"},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			var flagVal bool
			var argsVal []string

			// build minimal command with a BoolFlag "flag"
			cmd := &Command{
				Name: "test",
				Flags: []Flag{
					&BoolFlag{
						Name:        "flag",
						Usage:       "a bool flag",
						Destination: &flagVal,
					},
				},
				Action: func(ctx context.Context, c *Command) error {
					argsVal = c.Args().Slice()
					return nil
				},
			}

			err := cmd.Run(context.Background(), tc.input)
			if tc.expectErr {
				assert.Error(t, err)
				if err != nil {
					assert.Contains(t, strings.ToLower(err.Error()), strings.ToLower(tc.errorContain))
				}
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tc.expectFlag, flagVal)
				assert.Equal(t, tc.expectArgs, argsVal)
			}
		})
	}
}

// TestSliceStringFlagParsing tests the StringSliceFlag
func TestSliceStringFlagParsing(t *testing.T) {
	var sliceVal []string

	cmdNoDelimiter := &Command{
		Name: "test",
		Flags: []Flag{
			&StringSliceFlag{
				Name:  "flag",
				Usage: "a string slice flag without delimiter",
			},
		},
		Action: func(ctx context.Context, c *Command) error {
			sliceVal = c.StringSlice("flag")
			return nil
		},
	}

	/*cmdWithDelimiter := &Command{
		Name: "test",
		Flags: []Flag{
			&StringSliceFlag{
				Name:      "flag",
				Usage:     "a string slice flag with delimiter",
				Delimiter: ':',
			},
		},
		Action: func(ctx context.Context, c *Command) error {
			sliceVal = c.StringSlice("flag")
			return nil
		},
	}*/

	tests := []struct {
		name         string
		cmd          *Command
		input        []string
		expectSlice  []string
		expectErr    bool
		errorContain string
	}{
		{
			name:        "single value without delimiter (no split)",
			cmd:         cmdNoDelimiter,
			input:       []string{"test", "--flag", "x"},
			expectSlice: []string{"x"},
		},
		{
			name:        "multiple values with comma (default split)",
			cmd:         cmdNoDelimiter,
			input:       []string{"test", "--flag", "x,y"},
			expectSlice: []string{"x", "y"},
		},
		/*{
			name:        "Case 10: with delimiter specified ':'",
			cmd:         cmdWithDelimiter,
			input:       []string{"test", "--flag", "x:y"},
			expectSlice: []string{"x", "y"},
		},*/
		{
			name:        "without delimiter specified, value remains unsplit",
			cmd:         cmdNoDelimiter,
			input:       []string{"test", "--flag", "x:y"},
			expectSlice: []string{"x:y"},
		},
	}

	for _, tc := range tests {
		// Reset sliceVal
		sliceVal = nil

		t.Run(tc.name, func(t *testing.T) {
			err := tc.cmd.Run(context.Background(), tc.input)
			if tc.expectErr {
				assert.Error(t, err)
				if err != nil {
					assert.Contains(t, strings.ToLower(err.Error()), strings.ToLower(tc.errorContain))
				}
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tc.expectSlice, sliceVal)
			}
		})
	}
}

func TestJSONExportCommand(t *testing.T) {
	cmd := buildExtendedTestCommand()
	cmd.Arguments = []Argument{
		&IntArgs{
			Name: "fooi",
		},
	}

	out, err := json.Marshal(cmd)
	require.NoError(t, err)

	expected := `{
		"name": "greet",
		"aliases": null,
		"usage": "Some app",
		"usageText": "app [first_arg] [second_arg]",
		"argsUsage": "",
		"version": "",
		"description": "Description of the application.",
		"defaultCommand": "",
		"category": "",
		"commands": [
		  {
			"name": "config",
			"aliases": [
			  "c"
			],
			"usage": "another usage test",
			"usageText": "",
			"argsUsage": "",
			"version": "",
			"description": "",
			"defaultCommand": "",
			"category": "",
			"commands": [
			  {
				"name": "sub-config",
				"aliases": [
				  "s",
				  "ss"
				],
				"usage": "another usage test",
				"usageText": "",
				"argsUsage": "",
				"version": "",
				"description": "",
				"defaultCommand": "",
				"category": "",
				"commands": null,
				"flags": [
				  {
					"name": "sub-flag",
					"category": "",
					"defaultText": "",
					"usage": "",
					"required": false,
					"hidden": false,
					"deprecated": "",
					"hideDefault": false,
					"local": false,
					"defaultValue": "",
					"aliases": [
					  "sub-fl",
					  "s"
					],
					"takesFileArg": false,
					"config": {
					  "TrimSpace": false
					},
					"onlyOnce": false,
					"validateDefaults" : false
				  },
				  {
					"name": "sub-command-flag",
					"category": "",
					"defaultText": "",
					"usage": "some usage text",
					"required": false,
					"hidden": false,
					"deprecated": "",
					"hideDefault": false,
					"local": false,
					"defaultValue": false,
					"aliases": [
					  "s"
					],
					"takesFileArg": false,
					"config": {
					  "Count": null
					},
					"onlyOnce": false,
					"validateDefaults" : false
				  }
				],
				"hideHelp": false,
				"hideHelpCommand": false,
				"hideVersion": false,
				"hidden": false,
				"deprecated": "",
				"authors": null,
				"copyright": "",
				"metadata": null,
				"sliceFlagSeparator": "",
				"disableSliceFlagSeparator": false,
				"mapFlagKeyValueSeparator": "",
				"useShortOptionHandling": false,
				"suggest": false,
				"allowExtFlags": false,
				"skipFlagParsing": false,
				"prefixMatchCommands": false,
				"mutuallyExclusiveFlags": null,
				"arguments": null,
				"readArgsFromStdin": false,
				"stopOnNthArg": null
			  }
			],
			"flags": [
			  {
				"name": "flag",
				"category": "",
				"defaultText": "",
				"usage": "",
				"required": false,
				"hidden": false,
				"deprecated": "",
				"hideDefault": false,
				"local": false,
				"defaultValue": "",
				"aliases": [
				  "fl",
				  "f"
				],
				"takesFileArg": true,
				"config": {
				  "TrimSpace": false
				},
				"onlyOnce": false,
				"validateDefaults" : false
			  },
			  {
				"name": "another-flag",
				"category": "",
				"defaultText": "",
				"usage": "another usage text",
				"required": false,
				"hidden": false,
				"deprecated": "",
				"hideDefault": false,
				"local": false,
				"defaultValue": false,
				"aliases": [
				  "b"
				],
				"takesFileArg": false,
				"config": {
				  "Count": null
				},
				"onlyOnce": false,
				"validateDefaults" : false
			  }
			],
			"hideHelp": false,
			"hideHelpCommand": false,
			"hideVersion": false,
			"hidden": false,
			"deprecated": "",
			"authors": null,
			"copyright": "",
			"metadata": null,
			"sliceFlagSeparator": "",
			"disableSliceFlagSeparator": false,
			"mapFlagKeyValueSeparator": "",
			"useShortOptionHandling": false,
			"suggest": false,
			"allowExtFlags": false,
			"skipFlagParsing": false,
			"prefixMatchCommands": false,
			"mutuallyExclusiveFlags": null,
			"arguments": null,
			"readArgsFromStdin": false,
			"stopOnNthArg": null
		  },
		  {
			"name": "info",
			"aliases": [
			  "i",
			  "in"
			],
			"usage": "retrieve generic information",
			"usageText": "",
			"argsUsage": "",
			"version": "",
			"description": "",
			"defaultCommand": "",
			"category": "",
			"commands": null,
			"flags": null,
			"hideHelp": false,
			"hideHelpCommand": false,
			"hideVersion": false,
			"hidden": false,
			"deprecated": "",
			"authors": null,
			"copyright": "",
			"metadata": null,
			"sliceFlagSeparator": "",
			"disableSliceFlagSeparator": false,
			"mapFlagKeyValueSeparator": "",
			"useShortOptionHandling": false,
			"suggest": false,
			"allowExtFlags": false,
			"skipFlagParsing": false,
			"prefixMatchCommands": false,
			"mutuallyExclusiveFlags": null,
			"arguments": null,
			"readArgsFromStdin": false,
			"stopOnNthArg": null
		  },
		  {
			"name": "some-command",
			"aliases": null,
			"usage": "",
			"usageText": "",
			"argsUsage": "",
			"version": "",
			"description": "",
			"defaultCommand": "",
			"category": "",
			"commands": null,
			"flags": null,
			"hideHelp": false,
			"hideHelpCommand": false,
			"hideVersion": false,
			"hidden": false,
			"deprecated": "",
			"authors": null,
			"copyright": "",
			"metadata": null,
			"sliceFlagSeparator": "",
			"disableSliceFlagSeparator": false,
			"mapFlagKeyValueSeparator": "",
			"useShortOptionHandling": false,
			"suggest": false,
			"allowExtFlags": false,
			"skipFlagParsing": false,
			"prefixMatchCommands": false,
			"mutuallyExclusiveFlags": null,
			"arguments": null,
			"readArgsFromStdin": false,
			"stopOnNthArg": null
		  },
		  {
			"name": "hidden-command",
			"aliases": null,
			"usage": "",
			"usageText": "",
			"argsUsage": "",
			"version": "",
			"description": "",
			"defaultCommand": "",
			"category": "",
			"commands": null,
			"flags": [
			  {
				"name": "completable",
				"category": "",
				"defaultText": "",
				"usage": "",
				"required": false,
				"hidden": false,
				"deprecated": "",
				"hideDefault": false,
				"local": false,
				"defaultValue": false,
				"aliases": null,
				"takesFileArg": false,
				"config": {
				  "Count": null
				},
				"onlyOnce": false,
				"validateDefaults": false
			  }
			],
			"hideHelp": false,
			"hideHelpCommand": false,
			"hideVersion": false,
			"hidden": true,
			"deprecated": "",
			"authors": null,
			"copyright": "",
			"metadata": null,
			"sliceFlagSeparator": "",
			"disableSliceFlagSeparator": false,
			"mapFlagKeyValueSeparator": "",
			"useShortOptionHandling": false,
			"suggest": false,
			"allowExtFlags": false,
			"skipFlagParsing": false,
			"prefixMatchCommands": false,
			"mutuallyExclusiveFlags": null,
			"arguments": null,
			"readArgsFromStdin": false,
			"stopOnNthArg": null
		  },
		  {
			"name": "usage",
			"aliases": [
			  "u"
			],
			"usage": "standard usage text",
			"usageText": "\nUsage for the usage text\n- formatted:  Based on the specified ConfigMap and summon secrets.yml\n- list:       Inspect the environment for a specific process running on a Pod\n- for_effect: Compare 'namespace' environment with 'local'\n\n` + "```\\nfunc() { ... }\\n```" + `\n\nShould be a part of the same code block\n",
			"argsUsage": "",
			"version": "",
			"description": "",
			"defaultCommand": "",
			"category": "",
			"commands": [
			  {
				"name": "sub-usage",
				"aliases": [
				  "su"
				],
				"usage": "standard usage text",
				"usageText": "Single line of UsageText",
				"argsUsage": "",
				"version": "",
				"description": "",
				"defaultCommand": "",
				"category": "",
				"commands": null,
				"flags": [
				  {
					"name": "sub-command-flag",
					"category": "",
					"defaultText": "",
					"usage": "some usage text",
					"required": false,
					"hidden": false,
					"deprecated": "",
					"hideDefault": false,
					"local": false,
					"defaultValue": false,
					"aliases": [
					  "s"
					],
					"takesFileArg": false,
					"config": {
					  "Count": null
					},
					"onlyOnce": false,
					"validateDefaults" : false
				  }
				],
				"hideHelp": false,
				"hideHelpCommand": false,
				"hideVersion": false,
				"hidden": false,
				"deprecated": "",
				"authors": null,
				"copyright": "",
				"metadata": null,
				"sliceFlagSeparator": "",
				"disableSliceFlagSeparator": false,
				"mapFlagKeyValueSeparator": "",
				"useShortOptionHandling": false,
				"suggest": false,
				"allowExtFlags": false,
				"skipFlagParsing": false,
				"prefixMatchCommands": false,
				"mutuallyExclusiveFlags": null,
				"arguments": null,
				"readArgsFromStdin": false,
				"stopOnNthArg": null
			  }
			],
			"flags": [
			  {
				"name": "flag",
				"category": "",
				"defaultText": "",
				"usage": "",
				"required": false,
				"hidden": false,
				"deprecated": "",
				"hideDefault": false,
				"local": false,
				"defaultValue": "",
				"aliases": [
				  "fl",
				  "f"
				],
				"takesFileArg": true,
				"config": {
				  "TrimSpace": false
				},
				"onlyOnce": false,
				"validateDefaults" : false
			  },
			  {
				"name": "another-flag",
				"category": "",
				"defaultText": "",
				"usage": "another usage text",
				"required": false,
				"hidden": false,
				"deprecated": "",
				"hideDefault": false,
				"local": false,
				"defaultValue": false,
				"aliases": [
				  "b"
				],
				"takesFileArg": false,
				"config": {
				  "Count": null
				},
				"onlyOnce": false,
				"validateDefaults" : false
			  }
			],
			"hideHelp": false,
			"hideHelpCommand": false,
			"hideVersion": false,
			"hidden": false,
			"deprecated": "",
			"authors": null,
			"copyright": "",
			"metadata": null,
			"sliceFlagSeparator": "",
			"disableSliceFlagSeparator": false,
			"mapFlagKeyValueSeparator": "",
			"useShortOptionHandling": false,
			"suggest": false,
			"allowExtFlags": false,
			"skipFlagParsing": false,
			"prefixMatchCommands": false,
			"mutuallyExclusiveFlags": null,
			"arguments": null,
			"readArgsFromStdin": false,
			"stopOnNthArg": null
		  }
		],
		"flags": [
		  {
			"name": "socket",
			"category": "",
			"defaultText": "",
			"usage": "some 'usage' text",
			"required": false,
			"hidden": false,
			"deprecated": "",
			"hideDefault": false,
			"local": false,
			"defaultValue": "value",
			"aliases": [
			  "s"
			],
			"takesFileArg": true,
			"config": {
			  "TrimSpace": false
			},
			"onlyOnce": false,
			"validateDefaults" : false
		  },
		  {
			"name": "flag",
			"category": "",
			"defaultText": "",
			"usage": "",
			"required": false,
			"hidden": false,
			"deprecated": "",
			"hideDefault": false,
			"local": false,
			"defaultValue": "",
			"aliases": [
			  "fl",
			  "f"
			],
			"takesFileArg": false,
			"config": {
			  "TrimSpace": false
			},
			"onlyOnce": false,
			"validateDefaults" : false
		  },
		  {
			"name": "another-flag",
			"category": "",
			"defaultText": "",
			"usage": "another usage text",
			"required": false,
			"hidden": false,
			"deprecated": "",
			"hideDefault": false,
			"local": false,
			"defaultValue": false,
			"aliases": [
			  "b"
			],
			"takesFileArg": false,
			"config": {
			  "Count": null
			},
			"onlyOnce": false,
			"validateDefaults" : false
		  },
		  {
			"name": "hidden-flag",
			"category": "",
			"defaultText": "",
			"usage": "",
			"required": false,
			"hidden": true,
			"deprecated": "",
			"hideDefault": false,
			"local": false,
			"defaultValue": false,
			"aliases": null,
			"takesFileArg": false,
			"config": {
			  "Count": null
			},
			"onlyOnce": false,
			"validateDefaults" : false
		  }
		],
		"hideHelp": false,
		"hideHelpCommand": false,
		"hideVersion": false,
		"hidden": false,
		"deprecated": "",
		"authors": [
		  "Harrison <harrison@lolwut.example.com>",
		  {
			"Name": "Oliver Allen",
			"Address": "oliver@toyshop.com"
		  }
		],
		"copyright": "",
		"metadata": null,
		"sliceFlagSeparator": "",
		"disableSliceFlagSeparator": false,
		"mapFlagKeyValueSeparator": "",
		"useShortOptionHandling": false,
		"suggest": false,
		"allowExtFlags": false,
		"skipFlagParsing": false,
		"prefixMatchCommands": false,
		"mutuallyExclusiveFlags": null,
		"arguments": [
		  {
			"name": "fooi",
			"value": 0,
			"usageText": "",
			"minTimes": 0,
			"maxTimes": 0,
			"config": {
			  "Base": 0
			}
		  }
		],
		"readArgsFromStdin": false,
		"stopOnNthArg": null
	  }
`
	assert.JSONEq(t, expected, string(out))
}

func TestCommand_ExclusiveFlags(t *testing.T) {
	cmd := &Command{
		Name: "bar",
		MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
			{
				Flags: [][]Flag{
					{
						&StringFlag{
							Name: "foo1",
						},
					},
					{
						&StringFlag{
							Name: "foo2",
						},
					},
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"bar", "--foo1", "var1", "--foo2", "var2"})

	require.Equal(t, "option foo1 cannot be set along with option foo2", err.Error())
}

func TestCommand_ExclusiveFlagsWithOnUsageError(t *testing.T) {
	expectedErr := errors.New("my custom error")
	cmd := &Command{
		Name: "bar",
		MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
			{
				Flags: [][]Flag{
					{
						&StringFlag{
							Name: "foo1",
						},
					},
					{
						&StringFlag{
							Name: "foo2",
						},
					},
				},
			},
		},
		OnUsageError: func(_ context.Context, _ *Command, _ error, _ bool) error {
			return expectedErr
		},
	}

	actualErr := cmd.Run(buildTestContext(t), []string{"bar", "--foo1", "v1", "--foo2", "v2"})

	require.ErrorIs(t, actualErr, expectedErr)
}

func TestCommand_ExclusiveFlagsWithAfter(t *testing.T) {
	var called bool
	cmd := &Command{
		Name: "bar",
		MutuallyExclusiveFlags: []MutuallyExclusiveFlags{
			{
				Category: "cat1",
				Flags: [][]Flag{
					{
						&StringFlag{
							Name: "foo",
						},
					},
					{
						&StringFlag{
							Name: "foo2",
						},
					},
				},
			},
		},
		After: func(ctx context.Context, cmd *Command) error {
			called = true
			return nil
		},
	}

	require.Error(t, cmd.Run(buildTestContext(t), []string{
		"bar",
		"--foo", "v1",
		"--foo2", "v2",
	}))
	require.True(t, called)
}

func TestCommand_ParallelRun(t *testing.T) {
	t.Parallel()

	for i := range 10 {
		t.Run(fmt.Sprintf("run_%d", i), func(t *testing.T) {
			t.Parallel()

			defer func() {
				if r := recover(); r != nil {
					t.Errorf("unexpected panic - '%s'", r)
				}
			}()

			cmd := &Command{
				Name:  "debug",
				Usage: "make an explosive entrance",
				Action: func(_ context.Context, cmd *Command) error {
					return nil
				},
			}

			if err := cmd.Run(context.Background(), nil); err != nil {
				fmt.Printf("%s\n", err)
			}
		})
	}
}

func TestCommand_ExclusiveFlagsPersistent(t *testing.T) {
	exclusiveGroup := func(flags ...string) []MutuallyExclusiveFlags {
		grp := MutuallyExclusiveFlags{}
		for _, name := range flags {
			grp.Flags = append(grp.Flags, []Flag{&StringFlag{Name: name}})
		}
		return []MutuallyExclusiveFlags{grp}
	}

	noop := func(_ context.Context, _ *Command) error { return nil }

	newBaseCmd := func() *Command {
		return &Command{
			Name:                   "root",
			MutuallyExclusiveFlags: exclusiveGroup("alpha", "beta"),
			Commands:               []*Command{{Name: "sub", Action: noop}},
		}
	}

	tests := []struct {
		name    string
		setup   func() *Command
		args    []string
		wantErr string
	}{
		{
			name:  "single flag propagated to subcommand",
			setup: newBaseCmd,
			args:  []string{"root", "sub", "--alpha", "hello"},
		},
		{
			name:    "both exclusive flags on subcommand errors",
			setup:   newBaseCmd,
			args:    []string{"root", "sub", "--alpha", "hello", "--beta", "world"},
			wantErr: "cannot be set along with",
		},
		{
			name:  "neither flag set without required is ok",
			setup: newBaseCmd,
			args:  []string{"root", "sub"},
		},
		{
			name: "exclusive flags checked on grandchild",
			setup: func() *Command {
				cmd := newBaseCmd()
				sub := cmd.Commands[0]
				sub.Name = "mid"
				sub.Action = nil
				sub.Commands = []*Command{{Name: "leaf", Action: noop}}
				return cmd
			},
			args:    []string{"root", "mid", "leaf", "--alpha", "hello", "--beta", "world"},
			wantErr: "cannot be set along with",
		},
		{
			name: "subcommand own group checked alongside parent group",
			setup: func() *Command {
				cmd := newBaseCmd()
				cmd.Commands[0].MutuallyExclusiveFlags = exclusiveGroup("gamma", "delta")
				return cmd
			},
			args:    []string{"root", "sub", "--gamma", "hello", "--delta", "world"},
			wantErr: "cannot be set along with",
		},
		{
			name: "parent group violation detected when subcommand has own group",
			setup: func() *Command {
				cmd := newBaseCmd()
				cmd.Commands[0].MutuallyExclusiveFlags = exclusiveGroup("gamma", "delta")
				return cmd
			},
			args:    []string{"root", "sub", "--alpha", "hello", "--beta", "world"},
			wantErr: "cannot be set along with",
		},
		{
			name: "parent and subcommand groups both pass independently",
			setup: func() *Command {
				cmd := newBaseCmd()
				cmd.Commands[0].MutuallyExclusiveFlags = exclusiveGroup("gamma", "delta")
				return cmd
			},
			args: []string{"root", "sub", "--alpha", "hello", "--gamma", "world"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := tt.setup().Run(buildTestContext(t), tt.args)
			if tt.wantErr != "" {
				require.Error(t, err)
				assert.Contains(t, err.Error(), tt.wantErr)
			} else {
				require.NoError(t, err)
			}
		})
	}
}

func TestEmptyPositionalArgs(t *testing.T) {
	testCases := []struct {
		Name     string
		Args     []string
		Expected []string
	}{
		{
			Name:     "empty arg between values",
			Args:     []string{"app", "hello", "", "world"},
			Expected: []string{"hello", "", "world"},
		},
		{
			Name:     "empty arg at start",
			Args:     []string{"app", "", "hello"},
			Expected: []string{"", "hello"},
		},
		{
			Name:     "whitespace-only arg",
			Args:     []string{"app", "hello", "  ", "world"},
			Expected: []string{"hello", "  ", "world"},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.Name, func(t *testing.T) {
			var args []string

			cmd := &Command{
				Action: func(_ context.Context, cmd *Command) error {
					args = cmd.Args().Slice()
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), tc.Args)
			assert.NoError(t, err)
			assert.Equal(t, tc.Expected, args)
		})
	}
}

// Regression for #2234: an empty positional arg following a flag used to be
// dropped along with every arg after it.
func TestEmptyPositionalArgsAfterFlag(t *testing.T) {
	testCases := []struct {
		Name         string
		Args         []string
		ExpectedArgs []string
		ExpectedFlag string
	}{
		{
			Name:         "empty arg after equals-form flag",
			Args:         []string{"app", "-f=something", "", "arg2", "arg3"},
			ExpectedArgs: []string{"", "arg2", "arg3"},
			ExpectedFlag: "something",
		},
		{
			Name:         "empty arg after space-form flag",
			Args:         []string{"app", "-f", "something", "", "arg2"},
			ExpectedArgs: []string{"", "arg2"},
			ExpectedFlag: "something",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.Name, func(t *testing.T) {
			var args []string
			var flagVal string

			cmd := &Command{
				Flags: []Flag{
					&StringFlag{Name: "f"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					args = cmd.Args().Slice()
					flagVal = cmd.String("f")
					return nil
				},
			}

			err := cmd.Run(buildTestContext(t), tc.Args)
			assert.NoError(t, err)
			assert.Equal(t, tc.ExpectedArgs, args)
			assert.Equal(t, tc.ExpectedFlag, flagVal)
		})
	}
}

func TestCommand_BooleanEqualsValue(t *testing.T) {
	tests := []struct {
		name    string
		args    []string
		inverse bool
		wantErr bool
		want    bool
	}{
		{name: "empty long value", args: []string{"--enabled="}, wantErr: true},
		{name: "empty short value", args: []string{"-e="}, wantErr: true},
		{name: "empty grouped value", args: []string{"-ve="}, wantErr: true},
		{name: "empty inverse-capable positive value", args: []string{"--enabled="}, inverse: true, wantErr: true},
		{name: "bare long flag", args: []string{"--enabled"}, want: true},
		{name: "explicit false", args: []string{"--enabled=false"}},
		{name: "grouped false", args: []string{"-ve=false"}},
		{name: "bare grouped flags", args: []string{"-ve"}, want: true},
		{name: "bare inverse flag", args: []string{"--no-enabled"}, inverse: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var called bool
			var enabled bool
			var flag Flag = &BoolFlag{Name: "enabled", Aliases: []string{"e"}}
			if tt.inverse {
				flag = &BoolWithInverseFlag{Name: "enabled", Aliases: []string{"e"}, Value: true}
			}
			cmd := &Command{
				UseShortOptionHandling: true,
				Writer:                 io.Discard,
				ErrWriter:              io.Discard,
				Flags:                  []Flag{&BoolFlag{Name: "v"}, flag},
				Action: func(_ context.Context, cmd *Command) error {
					called = true
					enabled = cmd.Bool("enabled")
					return nil
				},
			}
			err := cmd.Run(buildTestContext(t), append([]string{"app"}, tt.args...))
			if tt.wantErr {
				require.ErrorContains(t, err, "parse error")
				assert.False(t, called)
				return
			}
			require.NoError(t, err)
			assert.True(t, called)
			assert.Equal(t, tt.want, enabled)
		})
	}
}

func TestFlagEqualsEmptyValue(t *testing.T) {
	t.Run("--flag= sets empty string", func(t *testing.T) {
		var val string

		cmd := &Command{
			Flags: []Flag{
				&StringFlag{
					Name:        "name",
					Destination: &val,
				},
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"app", "--name="})
		assert.NoError(t, err)
		assert.Equal(t, "", val)
	})

	t.Run("--flag= does not consume next positional arg", func(t *testing.T) {
		var val string
		var args []string

		cmd := &Command{
			Flags: []Flag{
				&StringFlag{
					Name:        "name",
					Destination: &val,
				},
			},
			Action: func(_ context.Context, cmd *Command) error {
				args = cmd.Args().Slice()
				return nil
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"app", "--name=", "positional"})
		assert.NoError(t, err)
		assert.Equal(t, "", val)
		assert.Equal(t, []string{"positional"}, args)
	})

	t.Run("-vn= in a short option group sets empty string", func(t *testing.T) {
		var val string
		var verbose bool
		var args []string

		cmd := &Command{
			UseShortOptionHandling: true,
			Flags: []Flag{
				&BoolFlag{Name: "v", Destination: &verbose},
				&StringFlag{Name: "n", Destination: &val, Value: "default"},
			},
			Action: func(_ context.Context, cmd *Command) error {
				args = cmd.Args().Slice()
				return nil
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"app", "-vn=", "positional"})
		assert.NoError(t, err)
		assert.True(t, verbose)
		assert.Equal(t, "", val)
		assert.Equal(t, []string{"positional"}, args)
	})

	t.Run("-vn= at the end of a short option group sets empty string", func(t *testing.T) {
		var val string
		var verbose bool

		cmd := &Command{
			UseShortOptionHandling: true,
			Flags: []Flag{
				&BoolFlag{Name: "v", Destination: &verbose},
				&StringFlag{Name: "n", Destination: &val, Value: "default"},
			},
		}

		err := cmd.Run(buildTestContext(t), []string{"app", "-vn="})
		assert.NoError(t, err)
		assert.True(t, verbose)
		assert.Equal(t, "", val)
	})
}

// TestCommand_NoDefaultCmdArgMatchingFlag tests the argument set
// of a command which has no default command, and has a flag with
// the name of the next argument
func TestCommand_NoDefaultCmdArgMatchingFlag(t *testing.T) {
	expectedArgs := stringSliceArgs{v: []string{"flag"}}
	var actualArgs Args
	cmd := &Command{
		Name: "rootCommand",
		Flags: []Flag{
			&StringFlag{
				Name: "flag",
			},
		},
		Commands: []*Command{
			{
				Name: "subCommand",
			},
		},
		Action: func(ctx context.Context, c *Command) error {
			actualArgs = c.Args()
			return nil
		},
	}
	// the last element - "flag" - is an argument sharing the same name as the flag
	// "flag" of the rootCommand command
	err := cmd.Run(buildTestContext(t), []string{"rootCommand", "--flag", "flagvalue", "flag"})
	require.NoError(t, err)
	require.Equal(t, &expectedArgs, actualArgs)
}

func TestDefaultCommandWithSubcommandFlags(t *testing.T) {
	// Regression test for https://github.com/urfave/cli/issues/2249
	// When DefaultCommand is set, flags defined on the default subcommand
	// should work even when the subcommand name is omitted.
	actionExecuted := false
	cmd := &Command{
		DefaultCommand: "run1",
		Commands: []*Command{
			{
				Name:  "run1",
				Usage: "run the main application",
				Action: func(ctx context.Context, cmd *Command) error {
					actionExecuted = true
					return nil
				},
				Flags: []Flag{
					&StringFlag{
						Name:     "foo",
						Required: true,
					},
				},
			},
			{
				Name: "run2",
				Action: func(ctx context.Context, cmd *Command) error {
					return nil
				},
				Flags: []Flag{
					&StringFlag{
						Name:     "value",
						Required: true,
					},
				},
			},
		},
	}

	// Using flag without subcommand name should route to default command
	err := cmd.Run(buildTestContext(t), []string{"c", "--foo", "bar"})
	assert.NoError(t, err)
	assert.True(t, actionExecuted, "expected run1 action to be executed")
}

func TestDefaultCommandWithShortFlag(t *testing.T) {
	// Covers the short-flag splitting path in parseFlags when DefaultCommand is set
	actionRun := false
	cmd := &Command{
		DefaultCommand: "run",
		Commands: []*Command{
			{
				Name:  "run",
				Usage: "run the app",
				Action: func(ctx context.Context, cmd *Command) error {
					actionRun = true
					if cmd.String("foo") != "baz" {
						return fmt.Errorf("expected foo=baz, got %s", cmd.String("foo"))
					}
					return nil
				},
				Flags: []Flag{
					&StringFlag{
						Name:    "foo",
						Aliases: []string{"f"},
					},
				},
			},
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"c", "-f", "baz"})
	assert.NoError(t, err)
	assert.True(t, actionRun, "expected run action to be executed")
}

func TestDefaultCommandWithShortFlagHandling(t *testing.T) {
	// Covers the shortOptionHandling for-loop path when DefaultCommand is set
	actionRun := false
	cmd := &Command{
		UseShortOptionHandling: true,
		DefaultCommand:         "run",
		Commands: []*Command{
			{
				Name:  "run",
				Usage: "run the app",
				Action: func(ctx context.Context, cmd *Command) error {
					actionRun = true
					if cmd.String("foo") != "baz" {
						return fmt.Errorf("expected foo=baz, got %s", cmd.String("foo"))
					}
					return nil
				},
				Flags: []Flag{
					&StringFlag{
						Name:    "foo",
						Aliases: []string{"f"},
					},
				},
			},
		},
	}
	err := cmd.Run(buildTestContext(t), []string{"c", "-f", "baz"})
	assert.NoError(t, err)
	assert.True(t, actionRun, "expected run action to be executed")
}

func TestCommand_Path(t *testing.T) {
	subCmd := &Command{Name: "bar"}
	subSubCmd := &Command{Name: "baz"}
	subCmd.Commands = []*Command{subSubCmd}

	cmd := &Command{
		Name:     "foo",
		Commands: []*Command{subCmd},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"foo", "bar", "baz"}))

	assert.Equal(t, []string{"foo"}, cmd.Path())
	assert.Equal(t, []string{"foo", "bar"}, subCmd.Path())
	assert.Equal(t, []string{"foo", "bar", "baz"}, subSubCmd.Path())
}

func TestCommand_Walk(t *testing.T) {
	subCmd := &Command{Name: "bar"}
	subSubCmd := &Command{Name: "baz"}
	subCmd.Commands = []*Command{subSubCmd}

	cmd := &Command{
		Name:     "foo",
		Commands: []*Command{subCmd},
	}

	var visited []string
	err := cmd.Walk(func(c *Command) error {
		visited = append(visited, c.Name)
		return nil
	})
	require.NoError(t, err)
	assert.Equal(t, []string{"foo", "bar", "baz"}, visited)
}

func TestCommand_Walk_ShortCircuit(t *testing.T) {
	subCmd := &Command{Name: "bar"}
	subSubCmd := &Command{Name: "baz"}
	subCmd.Commands = []*Command{subSubCmd}

	cmd := &Command{
		Name:     "foo",
		Commands: []*Command{subCmd},
	}

	errWalk := fmt.Errorf("stop")
	var visited []string
	err := cmd.Walk(func(c *Command) error {
		visited = append(visited, c.Name)
		if c.Name == "bar" {
			return errWalk
		}
		return nil
	})
	assert.ErrorIs(t, err, errWalk)
	assert.Equal(t, []string{"foo", "bar"}, visited)
}

func TestCommand_Walk_Hidden(t *testing.T) {
	subCmd := &Command{Name: "bar", HideHelp: true}
	subSubCmd := &Command{Name: "baz"}
	subCmd.Commands = []*Command{subSubCmd}

	cmd := &Command{
		Name:     "foo",
		Commands: []*Command{subCmd},
	}

	var visited []string
	err := cmd.Walk(func(c *Command) error {
		visited = append(visited, c.Name)
		return nil
	})
	require.NoError(t, err)
	assert.Equal(t, []string{"foo", "bar", "baz"}, visited)
}

func TestCommand_Walk_NilFn(t *testing.T) {
	cmd := &Command{Name: "foo"}
	assert.Nil(t, cmd.Walk(nil))
}

func TestCommand_ArgValidator_RunsBeforeAction(t *testing.T) {
	var validated bool
	var actionRan bool

	cmd := &Command{
		Name: "test",
		ArgValidator: func(_ context.Context, _ *Command) error {
			validated = true
			return nil
		},
		Action: func(_ context.Context, _ *Command) error {
			actionRan = true
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"test"})
	require.NoError(t, err)
	assert.True(t, validated)
	assert.True(t, actionRan)
}

func TestCommand_ArgValidator_ErrorShortCircuitsAction(t *testing.T) {
	var actionRan bool

	cmd := &Command{
		Name: "test",
		ArgValidator: func(_ context.Context, _ *Command) error {
			return fmt.Errorf("validation failed")
		},
		Action: func(_ context.Context, _ *Command) error {
			actionRan = true
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"test"})
	assert.ErrorContains(t, err, "validation failed")
	assert.False(t, actionRan)
}

func TestCommand_ArgValidator_InheritsFromParent(t *testing.T) {
	var validated bool

	root := &Command{
		Name: "root",
		ArgValidator: func(_ context.Context, _ *Command) error {
			validated = true
			return nil
		},
		Commands: []*Command{
			{
				Name:   "sub",
				Action: func(_ context.Context, _ *Command) error { return nil },
			},
		},
	}

	err := root.Run(buildTestContext(t), []string{"root", "sub"})
	require.NoError(t, err)
	assert.True(t, validated)
}

func TestCommand_ArgValidator_SubcommandOverride(t *testing.T) {
	var parentValidated bool
	var childValidated bool

	root := &Command{
		Name: "root",
		ArgValidator: func(_ context.Context, _ *Command) error {
			parentValidated = true
			return nil
		},
		Commands: []*Command{
			{
				Name: "sub",
				ArgValidator: func(_ context.Context, _ *Command) error {
					childValidated = true
					return nil
				},
				Action: func(_ context.Context, _ *Command) error { return nil },
			},
		},
	}

	err := root.Run(buildTestContext(t), []string{"root", "sub"})
	require.NoError(t, err)
	assert.False(t, parentValidated, "should use child's validator, not parent's")
	assert.True(t, childValidated)
}

func TestCommand_ArgValidator_RunsBeforeBefore(t *testing.T) {
	var order []string

	cmd := &Command{
		Name: "test",
		ArgValidator: func(_ context.Context, _ *Command) error {
			order = append(order, "validator")
			return nil
		},
		Before: func(_ context.Context, _ *Command) (context.Context, error) {
			order = append(order, "before")
			return nil, nil
		},
		Action: func(_ context.Context, _ *Command) error {
			order = append(order, "action")
			return nil
		},
	}

	err := cmd.Run(buildTestContext(t), []string{"test"})
	require.NoError(t, err)
	assert.Equal(t, []string{"validator", "before", "action"}, order)
}

// TestRunWithNoOsArgs checks that Run does not panic when handed an empty
// argument slice. In particular, the combination of an empty Name and
// EnableShellCompletion exercises both the setupDefaults empty-name guard
// and the buildCompletionCommand("") append together.
func TestRunWithNoOsArgs(t *testing.T) {
	for _, tst := range []struct {
		name     string
		cmd      *Command
		wantName string
	}{
		{name: "plain", cmd: &Command{Name: "foo"}, wantName: "foo"},
		{name: "shell completion enabled", cmd: &Command{Name: "foo", EnableShellCompletion: true}, wantName: "foo"},
		{name: "no name", cmd: &Command{}},
		{name: "no name, shell completion enabled", cmd: &Command{EnableShellCompletion: true}},
	} {
		t.Run(tst.name, func(t *testing.T) {
			called := false
			tst.cmd.Action = func(context.Context, *Command) error {
				called = true
				return nil
			}

			require.NotPanics(t, func() {
				require.NoError(t, tst.cmd.Run(buildTestContext(t), []string{}))
			})
			assert.True(t, called)
			assert.Equal(t, tst.wantName, tst.cmd.Name)
		})
	}
}

func TestCommand_Deprecated(t *testing.T) {
	newCmd := func() *Command {
		return &Command{
			Name: "app",
			Flags: []Flag{
				&StringFlag{Name: "old-flag", Aliases: []string{"o"}, Deprecated: "use --new-flag instead"},
				&StringFlag{Name: "x", Deprecated: "use --new-flag instead"},
				&StringFlag{Name: "env-flag", Sources: EnvVars("APP_ENV_FLAG"), Deprecated: "use --new-flag instead"},
				&BoolWithInverseFlag{Name: "color", Deprecated: "it is always on"},
				&StringFlag{Name: "new-flag"},
			},
			Commands: []*Command{
				{
					Name:       "old",
					Deprecated: "use \"new\" instead",
				},
				{
					Name: "new",
				},
				{
					Name:       "group",
					Deprecated: "use \"new\" instead",
					Commands: []*Command{
						{Name: "sub"},
					},
				},
			},
			Action: func(context.Context, *Command) error { return nil },
		}
	}

	tests := []struct {
		name    string
		args    []string
		env     map[string]string
		wantErr string
	}{
		{
			name: "nothing deprecated used",
			args: []string{"app", "--new-flag", "v", "new"},
		},
		{
			name:    "deprecated command",
			args:    []string{"app", "old"},
			wantErr: "Command \"old\" is deprecated, use \"new\" instead\n",
		},
		{
			name:    "deprecated parent command",
			args:    []string{"app", "group", "sub"},
			wantErr: "Command \"group\" is deprecated, use \"new\" instead\n",
		},
		{
			name:    "deprecated flag",
			args:    []string{"app", "--old-flag", "v"},
			wantErr: "Flag --old-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name:    "deprecated flag set by alias",
			args:    []string{"app", "-o", "v"},
			wantErr: "Flag --old-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name:    "deprecated short flag",
			args:    []string{"app", "-x", "v"},
			wantErr: "Flag -x has been deprecated, use --new-flag instead\n",
		},
		{
			name:    "deprecated inverse bool flag",
			args:    []string{"app", "--no-color"},
			wantErr: "Flag --color has been deprecated, it is always on\n",
		},
		{
			name:    "deprecated flag set from env",
			args:    []string{"app"},
			env:     map[string]string{"APP_ENV_FLAG": "v"},
			wantErr: "Flag --env-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name:    "deprecated persistent flag set on subcommand",
			args:    []string{"app", "new", "--old-flag", "v"},
			wantErr: "Flag --old-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name:    "deprecated persistent flag set on parent and subcommand warns once",
			args:    []string{"app", "--old-flag", "v", "new", "--old-flag", "w"},
			wantErr: "Flag --old-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name: "deprecated command and flag",
			args: []string{"app", "old", "--old-flag", "v"},
			wantErr: "Command \"old\" is deprecated, use \"new\" instead\n" +
				"Flag --old-flag has been deprecated, use --new-flag instead\n",
		},
		{
			name: "help for deprecated command",
			args: []string{"app", "old", "--help"},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			for k, v := range test.env {
				t.Setenv(k, v)
			}

			var errBuf bytes.Buffer
			cmd := newCmd()
			cmd.Writer = io.Discard
			cmd.ErrWriter = &errBuf

			require.NoError(t, cmd.Run(buildTestContext(t), test.args))
			assert.Equal(t, test.wantErr, errBuf.String())
		})
	}
}

func TestCommand_DeprecatedStillRuns(t *testing.T) {
	var got string
	cmd := &Command{
		Name:      "app",
		ErrWriter: io.Discard,
		Commands: []*Command{
			{
				Name:       "old",
				Deprecated: "use \"new\" instead",
				Flags: []Flag{
					&StringFlag{Name: "old-flag", Deprecated: "use --new-flag instead"},
				},
				Action: func(_ context.Context, cmd *Command) error {
					got = cmd.String("old-flag")
					return nil
				},
			},
		},
	}

	require.NoError(t, cmd.Run(buildTestContext(t), []string{"app", "old", "--old-flag", "v"}))
	assert.Equal(t, "v", got)
}