Source: golang-github-alecthomas-kong
Version: 0.3.0-1
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: lu...@debian.org
Usertags: ftbfs-20220813 ftbfs-bookworm

Hi,

During a rebuild of all packages in sid, your package failed to build
on amd64.


Relevant part (hopefully):
>  debian/rules binary
> dh binary --buildsystem=golang --with=golang
>    dh_update_autotools_config -O--buildsystem=golang
>    dh_autoreconf -O--buildsystem=golang
>    dh_auto_configure -O--buildsystem=golang
>    dh_auto_build -O--buildsystem=golang
>       cd obj-x86_64-linux-gnu && go install -trimpath -v -p 8 
> github.com/alecthomas/kong
> internal/goarch
> internal/race
> internal/goexperiment
> internal/goos
> internal/unsafeheader
> runtime/internal/syscall
> internal/cpu
> runtime/internal/atomic
> runtime/internal/math
> internal/abi
> sync/atomic
> unicode
> runtime/internal/sys
> unicode/utf8
> encoding
> math/bits
> internal/itoa
> unicode/utf16
> internal/bytealg
> math
> runtime
> sync
> internal/reflectlite
> internal/testlog
> runtime/cgo
> errors
> sort
> io
> internal/oserror
> strconv
> path
> syscall
> strings
> bytes
> reflect
> regexp/syntax
> time
> internal/syscall/unix
> internal/syscall/execenv
> regexp
> io/fs
> internal/poll
> os
> internal/fmtsort
> encoding/binary
> encoding/base64
> path/filepath
> fmt
> internal/lazyregexp
> io/ioutil
> github.com/pkg/errors
> net/url
> go/token
> go/doc/comment
> os/user
> encoding/json
> go/scanner
> go/ast
> go/doc
> github.com/alecthomas/kong
>    dh_auto_test -O--buildsystem=golang
>       cd obj-x86_64-linux-gnu && go test -vet=off -v -p 8 
> github.com/alecthomas/kong
> === RUN   TestApplyDefaults
> === RUN   TestApplyDefaults/DefaultsWhenNotSet
> === RUN   TestApplyDefaults/PartiallySetDefaults
> --- PASS: TestApplyDefaults (0.00s)
>     --- PASS: TestApplyDefaults/DefaultsWhenNotSet (0.00s)
>     --- PASS: TestApplyDefaults/PartiallySetDefaults (0.00s)
> === RUN   TestParseHandlingBadBuild
> --- PASS: TestParseHandlingBadBuild (0.00s)
> === RUN   TestInterpolate
> --- PASS: TestInterpolate (0.00s)
> === RUN   TestHasInterpolatedVar
> --- PASS: TestHasInterpolatedVar (0.00s)
> === RUN   TestOptions
> --- PASS: TestOptions (0.00s)
> === RUN   TestBindTo
> --- PASS: TestBindTo (0.00s)
> === RUN   TestInvalidCallback
> --- PASS: TestInvalidCallback (0.00s)
> === RUN   TestCallbackCustomError
> --- PASS: TestCallbackCustomError (0.00s)
> === RUN   TestBindToProvider
> --- PASS: TestBindToProvider (0.00s)
> === RUN   TestScannerTake
> --- PASS: TestScannerTake (0.00s)
> === RUN   TestScannerPeek
> --- PASS: TestScannerPeek (0.00s)
> === RUN   TestConfigFlag
> --- PASS: TestConfigFlag (0.00s)
> === RUN   TestVersionFlag
> --- PASS: TestVersionFlag (0.00s)
> === RUN   TestChangeDirFlag
> --- PASS: TestChangeDirFlag (0.00s)
> === RUN   TestMultipleConfigLoading
> --- PASS: TestMultipleConfigLoading (0.00s)
> === RUN   TestConfigValidation
> --- PASS: TestConfigValidation (0.00s)
> === RUN   TestHelpOptionalArgs
> --- PASS: TestHelpOptionalArgs (0.00s)
> === RUN   TestHelp
> === RUN   TestHelp/Full
>     help_test.go:123: Usage: test-app --required <command>
>         
>         A test app.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>           -s, --[no-]sort            Is sortable or not.
>         
>         Commands:
>           one --required
>             A subcommand.
>         
>           two <three> --required --required-two --required-three
>             Sub-sub-arg.
>         
>           two four --required --required-two
>             Sub-sub-command.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
>     help_test.go:124: Usage: test-app --required <command>
>         
>         A test app.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>           -s, --[no-]sort            Is sortable or not.
>         
>         Commands:
>           one --required
>             A subcommand.
>         
>           two <three> --required --required-two --required-three
>             Sub-sub-arg.
>         
>           two four --required --required-two
>             Sub-sub-command.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
> === RUN   TestHelp/Selected
>     help_test.go:157: Usage: test-app two <three> --required --required-two 
> --required-three
>         
>         Sub-sub-arg.
>         
>         Detailed help provided through the HelpProvider interface.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>           -s, --[no-]sort            Is sortable or not.
>         
>               --flag=STRING          Nested flag under two.
>               --required-two
>         
>               --required-three
>         
>     help_test.go:158: Usage: test-app two <three> --required --required-two 
> --required-three
>         
>         Sub-sub-arg.
>         
>         Detailed help provided through the HelpProvider interface.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>           -s, --[no-]sort            Is sortable or not.
>         
>               --flag=STRING          Nested flag under two.
>               --required-two
>         
>               --required-three
>         
> --- PASS: TestHelp (0.00s)
>     --- PASS: TestHelp/Full (0.00s)
>     --- PASS: TestHelp/Selected (0.00s)
> === RUN   TestFlagsLast
> === RUN   TestFlagsLast/Full
>     help_test.go:232: Usage: test-app --required <command>
>         
>         A test app.
>         
>         Commands:
>           one --required
>             A subcommand.
>         
>           two <three> --required --required-two --required-three
>             Sub-sub-arg.
>         
>           two four --required --required-two
>             Sub-sub-command.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
>     help_test.go:233: Usage: test-app --required <command>
>         
>         A test app.
>         
>         Commands:
>           one --required
>             A subcommand.
>         
>           two <three> --required --required-two --required-three
>             Sub-sub-arg.
>         
>           two four --required --required-two
>             Sub-sub-command.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
> === RUN   TestFlagsLast/Selected
>     help_test.go:265: Usage: test-app two <three> --required --required-two 
> --required-three
>         
>         Sub-sub-arg.
>         
>         Detailed help provided through the HelpProvider interface.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>         
>               --flag=STRING          Nested flag under two.
>               --required-two
>         
>               --required-three
>         
>     help_test.go:266: Usage: test-app two <three> --required --required-two 
> --required-three
>         
>         Sub-sub-arg.
>         
>         Detailed help provided through the HelpProvider interface.
>         
>         Flags:
>           -h, --help                 Show context-sensitive help.
>               --string=STRING        A string flag.
>               --bool                 A bool flag with very long help that 
> wraps a lot
>                                      and is verbose and is really verbose.
>               --slice=STR,...        A slice of strings.
>               --map=KEY=VALUE;...    A map of strings to ints.
>               --required             A required flag.
>         
>               --flag=STRING          Nested flag under two.
>               --required-two
>         
>               --required-three
>         
> --- PASS: TestFlagsLast (0.00s)
>     --- PASS: TestFlagsLast/Full (0.00s)
>     --- PASS: TestFlagsLast/Selected (0.00s)
> === RUN   TestHelpTree
> === RUN   TestHelpTree/Full
> === RUN   TestHelpTree/Selected
> --- PASS: TestHelpTree (0.00s)
>     --- PASS: TestHelpTree/Full (0.00s)
>     --- PASS: TestHelpTree/Selected (0.00s)
> === RUN   TestHelpCompactNoExpand
> === RUN   TestHelpCompactNoExpand/Full
> === RUN   TestHelpCompactNoExpand/Selected
> --- PASS: TestHelpCompactNoExpand (0.00s)
>     --- PASS: TestHelpCompactNoExpand/Full (0.00s)
>     --- PASS: TestHelpCompactNoExpand/Selected (0.00s)
> === RUN   TestEnvarAutoHelp
> --- PASS: TestEnvarAutoHelp (0.00s)
> === RUN   TestEnvarAutoHelpWithEnvPrefix
> --- PASS: TestEnvarAutoHelpWithEnvPrefix (0.00s)
> === RUN   TestCustomValueFormatter
> --- PASS: TestCustomValueFormatter (0.00s)
> === RUN   TestHelpGrouping
> === RUN   TestHelpGrouping/Full
>     help_test.go:603: Usage: test-app <command>
>         
>         A test app.
>         
>         Flags:
>           -h, --help                  Show context-sensitive help.
>               --free-string=STRING    A non grouped string flag.
>               --free-bool             A non grouped bool flag.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           --grouped-a-string=STRING    A string flag grouped in A.
>           --grouped-a-bool             A bool flag grouped in A.
>         
>         Group B
>           --grouped-b-string=STRING    A string flag grouped in B.
>         
>         Commands:
>           two
>             A non grouped subcommand.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           one thing <arg>
>             subcommand thing
>         
>           one <other>
>             subcommand other
>         
>           three
>             Another subcommand grouped in A.
>         
>         Group B
>           one <stuff>
>             subcommand stuff
>         
>           four
>             Another subcommand grouped in B.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
>     help_test.go:604: Usage: test-app <command>
>         
>         A test app.
>         
>         Flags:
>           -h, --help                  Show context-sensitive help.
>               --free-string=STRING    A non grouped string flag.
>               --free-bool             A non grouped bool flag.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           --grouped-a-string=STRING    A string flag grouped in A.
>           --grouped-a-bool             A bool flag grouped in A.
>         
>         Group B
>           --grouped-b-string=STRING    A string flag grouped in B.
>         
>         Commands:
>           two
>             A non grouped subcommand.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           one thing <arg>
>             subcommand thing
>         
>           one <other>
>             subcommand other
>         
>           three
>             Another subcommand grouped in A.
>         
>         Group B
>           one <stuff>
>             subcommand stuff
>         
>           four
>             Another subcommand grouped in B.
>         
>         Run "test-app <command> --help" for more information on a command.
>         
> === RUN   TestHelpGrouping/Selected
>     help_test.go:645: Usage: test-app two
>         
>         A non grouped subcommand.
>         
>         Flags:
>           -h, --help                    Show context-sensitive help.
>               --free-string=STRING      A non grouped string flag.
>               --free-bool               A non grouped bool flag.
>         
>               --a-free-string=STRING    A non grouped string flag.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           --grouped-a-string=STRING    A string flag grouped in A.
>           --grouped-a-bool             A bool flag grouped in A.
>         
>           --a-grouped-a-string         A string flag grouped in A.
>         
>         Group B
>           --grouped-b-string=STRING    A string flag grouped in B.
>         
>         Another group title, this time without header
>           --grouped-1-string=STRING    A string flag grouped in 1.
>           --grouped-1-bool             A bool flag grouped in 1.
>         
>         Group 2
>           --grouped-2-string=STRING    A string flag grouped in 2.
>         
>     help_test.go:646: Usage: test-app two
>         
>         A non grouped subcommand.
>         
>         Flags:
>           -h, --help                    Show context-sensitive help.
>               --free-string=STRING      A non grouped string flag.
>               --free-bool               A non grouped bool flag.
>         
>               --a-free-string=STRING    A non grouped string flag.
>         
>         Group title taken from the kong.ExplicitGroups option
>           A group header
>         
>           --grouped-a-string=STRING    A string flag grouped in A.
>           --grouped-a-bool             A bool flag grouped in A.
>         
>           --a-grouped-a-string         A string flag grouped in A.
>         
>         Group B
>           --grouped-b-string=STRING    A string flag grouped in B.
>         
>         Another group title, this time without header
>           --grouped-1-string=STRING    A string flag grouped in 1.
>           --grouped-1-bool             A bool flag grouped in 1.
>         
>         Group 2
>           --grouped-2-string=STRING    A string flag grouped in 2.
>         
> --- PASS: TestHelpGrouping (0.00s)
>     --- PASS: TestHelpGrouping/Full (0.00s)
>     --- PASS: TestHelpGrouping/Selected (0.00s)
> === RUN   TestUsageOnError
> --- PASS: TestUsageOnError (0.00s)
> === RUN   TestShortUsageOnError
> --- PASS: TestShortUsageOnError (0.00s)
> === RUN   TestCustomShortUsageOnError
> --- PASS: TestCustomShortUsageOnError (0.00s)
> === RUN   TestCustomWrap
>     help_test.go:758: Usage: test-app
>         
>         A test app.
>         
>         Flags:
>           -h, --help           Show context-sensitive
>                                help.
>               --flag=STRING    A string flag with very
>                                long help that wraps a
>                                lot and is verbose and is
>                                really verbose.
>         
>     help_test.go:759: Usage: test-app
>         
>         A test app.
>         
>         Flags:
>           -h, --help           Show context-sensitive
>                                help.
>               --flag=STRING    A string flag with very
>                                long help that wraps a lot
>                                and is verbose and is
>                                really verbose.
>         
>     help_test.go:760: 
>               Error Trace:    help_test.go:760
>               Error:          Not equal: 
>                               expected: "Usage: test-app\n\nA test 
> app.\n\nFlags:\n  -h, --help           Show context-sensitive\n               
>         help.\n      --flag=STRING    A string flag with very\n               
>         long help that wraps a lot\n                       and is verbose and 
> is\n                       really verbose.\n"
>                               actual  : "Usage: test-app\n\nA test 
> app.\n\nFlags:\n  -h, --help           Show context-sensitive\n               
>         help.\n      --flag=STRING    A string flag with very\n               
>         long help that wraps a\n                       lot and is verbose and 
> is\n                       really verbose.\n"
>                               
>                               Diff:
>                               --- Expected
>                               +++ Actual
>                               @@ -8,4 +8,4 @@
>                                      --flag=STRING    A string flag with very
>                               -                       long help that wraps a 
> lot
>                               -                       and is verbose and is
>                               +                       long help that wraps a
>                               +                       lot and is verbose and 
> is
>                                                       really verbose.
>               Test:           TestCustomWrap
> --- FAIL: TestCustomWrap (0.00s)
> === RUN   TestPositionalArguments
> === RUN   TestPositionalArguments/Missing
> --- PASS: TestPositionalArguments (0.00s)
>     --- PASS: TestPositionalArguments/Missing (0.00s)
> === RUN   TestBranchingArgument
> === RUN   TestBranchingArgument/Missing
> --- PASS: TestBranchingArgument (0.00s)
>     --- PASS: TestBranchingArgument/Missing (0.00s)
> === RUN   TestResetWithDefaults
> --- PASS: TestResetWithDefaults (0.00s)
> === RUN   TestFlagSlice
> --- PASS: TestFlagSlice (0.00s)
> === RUN   TestFlagSliceWithSeparator
> --- PASS: TestFlagSliceWithSeparator (0.00s)
> === RUN   TestArgSlice
> --- PASS: TestArgSlice (0.00s)
> === RUN   TestArgSliceWithSeparator
> --- PASS: TestArgSliceWithSeparator (0.00s)
> === RUN   TestUnsupportedFieldErrors
> --- PASS: TestUnsupportedFieldErrors (0.00s)
> === RUN   TestMatchingArgField
> --- PASS: TestMatchingArgField (0.00s)
> === RUN   TestCantMixPositionalAndBranches
> --- PASS: TestCantMixPositionalAndBranches (0.00s)
> === RUN   TestPropagatedFlags
> --- PASS: TestPropagatedFlags (0.00s)
> === RUN   TestRequiredFlag
> --- PASS: TestRequiredFlag (0.00s)
> === RUN   TestOptionalArg
> --- PASS: TestOptionalArg (0.00s)
> === RUN   TestOptionalArgWithDefault
> --- PASS: TestOptionalArgWithDefault (0.00s)
> === RUN   TestArgWithDefaultIsOptional
> --- PASS: TestArgWithDefaultIsOptional (0.00s)
> === RUN   TestRequiredArg
> --- PASS: TestRequiredArg (0.00s)
> === RUN   TestInvalidRequiredAfterOptional
> --- PASS: TestInvalidRequiredAfterOptional (0.00s)
> === RUN   TestOptionalStructArg
> === RUN   TestOptionalStructArg/WithFlag
> === RUN   TestOptionalStructArg/WithoutFlag
> === RUN   TestOptionalStructArg/WithNothing
> --- PASS: TestOptionalStructArg (0.00s)
>     --- PASS: TestOptionalStructArg/WithFlag (0.00s)
>     --- PASS: TestOptionalStructArg/WithoutFlag (0.00s)
>     --- PASS: TestOptionalStructArg/WithNothing (0.00s)
> === RUN   TestMixedRequiredArgs
> === RUN   TestMixedRequiredArgs/SingleRequired
> === RUN   TestMixedRequiredArgs/ExtraOptional
> --- PASS: TestMixedRequiredArgs (0.00s)
>     --- PASS: TestMixedRequiredArgs/SingleRequired (0.00s)
>     --- PASS: TestMixedRequiredArgs/ExtraOptional (0.00s)
> === RUN   TestInvalidDefaultErrors
> --- PASS: TestInvalidDefaultErrors (0.00s)
> === RUN   TestCommandMissingTagIsInvalid
> --- PASS: TestCommandMissingTagIsInvalid (0.00s)
> === RUN   TestDuplicateFlag
> --- PASS: TestDuplicateFlag (0.00s)
> === RUN   TestDuplicateFlagOnPeerCommandIsOkay
> --- PASS: TestDuplicateFlagOnPeerCommandIsOkay (0.00s)
> === RUN   TestTraceErrorPartiallySucceeds
> --- PASS: TestTraceErrorPartiallySucceeds (0.00s)
> === RUN   TestNegatableFlag
> === RUN   TestNegatableFlag/no_flag
> === RUN   TestNegatableFlag/boolean_flag
> === RUN   TestNegatableFlag/inverted_boolean_flag
> === RUN   TestNegatableFlag/negated_boolean_flag
> === RUN   TestNegatableFlag/inverted_negated_boolean_flag
> --- PASS: TestNegatableFlag (0.00s)
>     --- PASS: TestNegatableFlag/no_flag (0.00s)
>     --- PASS: TestNegatableFlag/boolean_flag (0.00s)
>     --- PASS: TestNegatableFlag/inverted_boolean_flag (0.00s)
>     --- PASS: TestNegatableFlag/negated_boolean_flag (0.00s)
>     --- PASS: TestNegatableFlag/inverted_negated_boolean_flag (0.00s)
> === RUN   TestExistingNoFlag
> --- PASS: TestExistingNoFlag (0.00s)
> === RUN   TestInvalidNegatedNonBool
> --- PASS: TestInvalidNegatedNonBool (0.00s)
> === RUN   TestHooks
> === RUN   TestHooks/Command
> === RUN   TestHooks/Arg
> === RUN   TestHooks/Flag
> === RUN   TestHooks/ArgAndFlag
> --- PASS: TestHooks (0.00s)
>     --- PASS: TestHooks/Command (0.00s)
>     --- PASS: TestHooks/Arg (0.00s)
>     --- PASS: TestHooks/Flag (0.00s)
>     --- PASS: TestHooks/ArgAndFlag (0.00s)
> === RUN   TestShort
> --- PASS: TestShort (0.00s)
> === RUN   TestDuplicateFlagChoosesLast
> --- PASS: TestDuplicateFlagChoosesLast (0.00s)
> === RUN   TestDuplicateSliceAccumulates
> --- PASS: TestDuplicateSliceAccumulates (0.00s)
> === RUN   TestMapFlag
> --- PASS: TestMapFlag (0.00s)
> === RUN   TestMapFlagWithSliceValue
> --- PASS: TestMapFlagWithSliceValue (0.00s)
> === RUN   TestEmbeddedStruct
> --- PASS: TestEmbeddedStruct (0.00s)
> === RUN   TestSliceWithDisabledSeparator
> --- PASS: TestSliceWithDisabledSeparator (0.00s)
> === RUN   TestMultilineMessage
> --- PASS: TestMultilineMessage (0.00s)
> === RUN   TestRun
> --- PASS: TestRun (0.00s)
> === RUN   TestInterpolationIntoModel
> --- PASS: TestInterpolationIntoModel (0.00s)
> === RUN   TestIssue244
> --- PASS: TestIssue244 (0.00s)
> === RUN   TestErrorMissingArgs
> --- PASS: TestErrorMissingArgs (0.00s)
> === RUN   TestBoolOverride
> --- PASS: TestBoolOverride (0.00s)
> === RUN   TestAnonymousPrefix
> --- PASS: TestAnonymousPrefix (0.00s)
> === RUN   TestEmbedInterface
> --- PASS: TestEmbedInterface (0.00s)
> === RUN   TestExcludedField
> --- PASS: TestExcludedField (0.00s)
> === RUN   TestUnnamedFieldEmbeds
> --- PASS: TestUnnamedFieldEmbeds (0.00s)
> === RUN   TestHooksCalledForDefault
> --- PASS: TestHooksCalledForDefault (0.00s)
> === RUN   TestEnum
> --- PASS: TestEnum (0.00s)
> === RUN   TestParentBindings
> --- PASS: TestParentBindings (0.00s)
> === RUN   TestNumericParamErrors
> --- PASS: TestNumericParamErrors (0.00s)
> === RUN   TestDefaultValueIsHyphen
> --- PASS: TestDefaultValueIsHyphen (0.00s)
> === RUN   TestDefaultEnumValidated
> --- PASS: TestDefaultEnumValidated (0.00s)
> === RUN   TestEnvarEnumValidated
> --- PASS: TestEnvarEnumValidated (0.00s)
> === RUN   TestXor
> --- PASS: TestXor (0.00s)
> === RUN   TestXorChild
> --- PASS: TestXorChild (0.00s)
> === RUN   TestMultiXor
> --- PASS: TestMultiXor (0.00s)
> === RUN   TestXorRequired
> --- PASS: TestXorRequired (0.00s)
> === RUN   TestXorRequiredMany
> --- PASS: TestXorRequiredMany (0.00s)
> === RUN   TestEnumSequence
> --- PASS: TestEnumSequence (0.00s)
> === RUN   TestIssue40EnumAcrossCommands
> --- PASS: TestIssue40EnumAcrossCommands (0.00s)
> === RUN   TestIssue179
> --- PASS: TestIssue179 (0.00s)
> === RUN   TestIssue153
> --- PASS: TestIssue153 (0.00s)
> === RUN   TestEnumArg
> --- PASS: TestEnumArg (0.00s)
> === RUN   TestDefaultCommand
> --- PASS: TestDefaultCommand (0.00s)
> === RUN   TestMultipleDefaultCommands
> --- PASS: TestMultipleDefaultCommands (0.00s)
> === RUN   TestDefaultCommandWithSubCommand
> --- PASS: TestDefaultCommandWithSubCommand (0.00s)
> === RUN   TestDefaultCommandWithAllowedSubCommand
> --- PASS: TestDefaultCommandWithAllowedSubCommand (0.00s)
> === RUN   TestDefaultCommandWithArgument
> --- PASS: TestDefaultCommandWithArgument (0.00s)
> === RUN   TestDefaultCommandWithAllowedArgument
> --- PASS: TestDefaultCommandWithAllowedArgument (0.00s)
> === RUN   TestDefaultCommandWithBranchingArgument
> --- PASS: TestDefaultCommandWithBranchingArgument (0.00s)
> === RUN   TestDefaultCommandWithAllowedBranchingArgument
> --- PASS: TestDefaultCommandWithAllowedBranchingArgument (0.00s)
> === RUN   TestDefaultCommandPrecedence
> --- PASS: TestDefaultCommandPrecedence (0.00s)
> === RUN   TestLoneHpyhen
> --- PASS: TestLoneHpyhen (0.00s)
> === RUN   TestPlugins
> --- PASS: TestPlugins (0.00s)
> === RUN   TestValidateApp
> --- PASS: TestValidateApp (0.00s)
> === RUN   TestValidateCmd
> --- PASS: TestValidateCmd (0.00s)
> === RUN   TestValidateFlag
> --- PASS: TestValidateFlag (0.00s)
> === RUN   TestValidateArg
> --- PASS: TestValidateArg (0.00s)
> === RUN   TestPointers
> --- PASS: TestPointers (0.00s)
> === RUN   TestDynamicCommands
> --- PASS: TestDynamicCommands (0.00s)
> === RUN   TestDuplicateShortflags
> --- PASS: TestDuplicateShortflags (0.00s)
> === RUN   TestDuplicateNestedShortFlags
> --- PASS: TestDuplicateNestedShortFlags (0.00s)
> === RUN   TestHydratePointerCommandsAndEmbeds
> --- PASS: TestHydratePointerCommandsAndEmbeds (0.00s)
> === RUN   TestIgnoreRegex
> --- PASS: TestIgnoreRegex (0.00s)
> === RUN   TestIgnoreRegexEmpty
> --- PASS: TestIgnoreRegexEmpty (0.00s)
> === RUN   TestOptionReturnsErr
> --- PASS: TestOptionReturnsErr (0.00s)
> === RUN   TestEnumValidation
> === RUN   TestEnumValidation/Arg
> === RUN   TestEnumValidation/RequiredArg
> === RUN   TestEnumValidation/OptionalArg
> === RUN   TestEnumValidation/RepeatedArgs
> === RUN   TestEnumValidation/RequiredRepeatedArgs
> === RUN   TestEnumValidation/OptionalRepeatedArgs
> === RUN   TestEnumValidation/EnumWithEmptyDefault
> --- PASS: TestEnumValidation (0.00s)
>     --- PASS: TestEnumValidation/Arg (0.00s)
>     --- PASS: TestEnumValidation/RequiredArg (0.00s)
>     --- PASS: TestEnumValidation/OptionalArg (0.00s)
>     --- PASS: TestEnumValidation/RepeatedArgs (0.00s)
>     --- PASS: TestEnumValidation/RequiredRepeatedArgs (0.00s)
>     --- PASS: TestEnumValidation/OptionalRepeatedArgs (0.00s)
>     --- PASS: TestEnumValidation/EnumWithEmptyDefault (0.00s)
> === RUN   TestPassthroughCmd
> === RUN   TestPassthroughCmd/Simple
> === RUN   TestPassthroughCmd/DashDash
> === RUN   TestPassthroughCmd/Flag
> === RUN   TestPassthroughCmd/FlagAndFlag
> === RUN   TestPassthroughCmd/NoArgs
> --- PASS: TestPassthroughCmd (0.00s)
>     --- PASS: TestPassthroughCmd/Simple (0.00s)
>     --- PASS: TestPassthroughCmd/DashDash (0.00s)
>     --- PASS: TestPassthroughCmd/Flag (0.00s)
>     --- PASS: TestPassthroughCmd/FlagAndFlag (0.00s)
>     --- PASS: TestPassthroughCmd/NoArgs (0.00s)
> === RUN   TestPassthroughCmdOnlyArgs
> --- PASS: TestPassthroughCmdOnlyArgs (0.00s)
> === RUN   TestPassthroughCmdOnlyStringArgs
> --- PASS: TestPassthroughCmdOnlyStringArgs (0.00s)
> === RUN   TestValueMapper
> --- PASS: TestValueMapper (0.00s)
> === RUN   TestTextUnmarshaler
> --- PASS: TestTextUnmarshaler (0.00s)
> === RUN   TestJSONUnmarshaler
> --- PASS: TestJSONUnmarshaler (0.00s)
> === RUN   TestNamedMapper
> --- PASS: TestNamedMapper (0.00s)
> === RUN   TestTimeMapper
> --- PASS: TestTimeMapper (0.00s)
> === RUN   TestDurationMapper
> --- PASS: TestDurationMapper (0.00s)
> === RUN   TestDurationMapperJSONResolver
> --- PASS: TestDurationMapperJSONResolver (0.00s)
> === RUN   TestSplitEscaped
> --- PASS: TestSplitEscaped (0.00s)
> === RUN   TestJoinEscaped
> --- PASS: TestJoinEscaped (0.00s)
> === RUN   TestMapWithNamedTypes
> --- PASS: TestMapWithNamedTypes (0.00s)
> === RUN   TestMapWithMultipleValues
> --- PASS: TestMapWithMultipleValues (0.00s)
> === RUN   TestMapWithDifferentSeparator
> --- PASS: TestMapWithDifferentSeparator (0.00s)
> === RUN   TestMapWithNoSeparator
> --- PASS: TestMapWithNoSeparator (0.00s)
> === RUN   TestURLMapper
> --- PASS: TestURLMapper (0.00s)
> === RUN   TestSliceConsumesRemainingPositionalArgs
> --- PASS: TestSliceConsumesRemainingPositionalArgs (0.00s)
> === RUN   TestPassthroughStopsParsing
> --- PASS: TestPassthroughStopsParsing (0.00s)
> === RUN   TestMapperValue
> --- PASS: TestMapperValue (0.00s)
> === RUN   TestFileContentFlag
> --- PASS: TestFileContentFlag (0.00s)
> === RUN   TestNamedFileContentFlag
> --- PASS: TestNamedFileContentFlag (0.00s)
> === RUN   TestNamedSliceTypesDontHaveEllipsis
> --- PASS: TestNamedSliceTypesDontHaveEllipsis (0.00s)
> === RUN   TestCounter
> --- PASS: TestCounter (0.00s)
> === RUN   TestNumbers
> === RUN   TestNumbers/Max
> === RUN   TestNumbers/Min
> --- PASS: TestNumbers (0.00s)
>     --- PASS: TestNumbers/Max (0.00s)
>     --- PASS: TestNumbers/Min (0.00s)
> === RUN   TestFileMapper
> --- PASS: TestFileMapper (0.00s)
> === RUN   TestPathMapper
> --- PASS: TestPathMapper (0.00s)
> === RUN   TestMapperPlaceHolder
> --- PASS: TestMapperPlaceHolder (0.00s)
> === RUN   TestMapperVarsContributor
> --- PASS: TestMapperVarsContributor (0.00s)
> === RUN   TestModelApplicationCommands
> --- PASS: TestModelApplicationCommands (0.00s)
> === RUN   TestFlagString
> --- PASS: TestFlagString (0.00s)
> === RUN   TestEnvarsFlagBasic
> --- PASS: TestEnvarsFlagBasic (0.00s)
> === RUN   TestEnvarsFlagOverride
> --- PASS: TestEnvarsFlagOverride (0.00s)
> === RUN   TestEnvarsTag
> --- PASS: TestEnvarsTag (0.00s)
> === RUN   TestEnvarsEnvPrefix
> --- PASS: TestEnvarsEnvPrefix (0.00s)
> === RUN   TestEnvarsNestedEnvPrefix
> --- PASS: TestEnvarsNestedEnvPrefix (0.00s)
> === RUN   TestEnvarsWithDefault
> --- PASS: TestEnvarsWithDefault (0.00s)
> === RUN   TestEnv
> --- PASS: TestEnv (0.00s)
> === RUN   TestJSONBasic
> --- PASS: TestJSONBasic (0.00s)
> === RUN   TestResolversWithMappers
> --- PASS: TestResolversWithMappers (0.00s)
> === RUN   TestResolverWithBool
> --- PASS: TestResolverWithBool (0.00s)
> === RUN   TestLastResolverWins
> --- PASS: TestLastResolverWins (0.00s)
> === RUN   TestResolverSatisfiesRequired
> --- PASS: TestResolverSatisfiesRequired (0.00s)
> === RUN   TestResolverTriggersHooks
> --- PASS: TestResolverTriggersHooks (0.00s)
> === RUN   TestValidatingResolverErrors
> --- PASS: TestValidatingResolverErrors (0.00s)
> === RUN   TestDefaultValueForOptionalArg
> --- PASS: TestDefaultValueForOptionalArg (0.00s)
> === RUN   TestNoValueInTag
> --- PASS: TestNoValueInTag (0.00s)
> === RUN   TestCommaInQuotes
> --- PASS: TestCommaInQuotes (0.00s)
> === RUN   TestBadString
> --- PASS: TestBadString (0.00s)
> === RUN   TestNoQuoteEnd
> --- PASS: TestNoQuoteEnd (0.00s)
> === RUN   TestEscapedQuote
> --- PASS: TestEscapedQuote (0.00s)
> === RUN   TestBareTags
> --- PASS: TestBareTags (0.00s)
> === RUN   TestBareTagsWithJsonTag
> --- PASS: TestBareTagsWithJsonTag (0.00s)
> === RUN   TestManySeps
> --- PASS: TestManySeps (0.00s)
> === RUN   TestTagSetOnEmbeddedStruct
> --- PASS: TestTagSetOnEmbeddedStruct (0.00s)
> === RUN   TestTagSetOnCommand
> --- PASS: TestTagSetOnCommand (0.00s)
> === RUN   TestTagSetOnFlag
> --- PASS: TestTagSetOnFlag (0.00s)
> === RUN   TestTagAliases
> --- PASS: TestTagAliases (0.00s)
> === RUN   TestTagAliasesConflict
> --- PASS: TestTagAliasesConflict (0.00s)
> === RUN   TestTagAliasesSub
> --- PASS: TestTagAliasesSub (0.00s)
> === RUN   TestInvalidRuneErrors
> --- PASS: TestInvalidRuneErrors (0.00s)
> FAIL
> FAIL  github.com/alecthomas/kong      0.034s
> FAIL
> dh_auto_test: error: cd obj-x86_64-linux-gnu && go test -vet=off -v -p 8 
> github.com/alecthomas/kong returned exit code 1


The full build log is available from:
http://qa-logs.debian.net/2022/08/13/golang-github-alecthomas-kong_0.3.0-1_unstable.log

All bugs filed during this archive rebuild are listed at:
https://bugs.debian.org/cgi-bin/pkgreport.cgi?tag=ftbfs-20220813;users=lu...@debian.org
or:
https://udd.debian.org/bugs/?release=na&merged=ign&fnewerval=7&flastmodval=7&fusertag=only&fusertagtag=ftbfs-20220813&fusertaguser=lu...@debian.org&allbugs=1&cseverity=1&ctags=1&caffected=1#results

A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!

If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects

If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.

Reply via email to