Skip to content

Commit 8b82618

Browse files
alecthomasalecthomas
committed
fix: tests
1 parent 0c6a9f3 commit 8b82618

5 files changed

Lines changed: 98 additions & 98 deletions

File tree

‎.golangci.yml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,3 +65,4 @@ issues:
6565
- 'bad syntax for struct tag key'
6666
- 'bad syntax for struct tag pair'
6767
- 'result .* \(error\) is always nil'
68+
- 'package io/ioutil is deprecated'

bin/.go-1.18.3.pkg renamed to bin/.go-1.19.1.pkg

File renamed without changes.

‎bin/go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
.go-1.18.3.pkg
1+
.go-1.19.1.pkg

‎bin/gofmt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
.go-1.18.3.pkg
1+
.go-1.19.1.pkg

‎kong_test.go‎

Lines changed: 95 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -1742,40 +1742,40 @@ func TestStringPointer(t *testing.T) {
17421742
Foo *string
17431743
}
17441744
k, err := kong.New(&cli)
1745-
require.NoError(t, err)
1746-
require.NotNil(t, k)
1745+
assert.NoError(t, err)
1746+
assert.NotZero(t, k)
17471747
ctx, err := k.Parse([]string{"--foo", "wtf"})
1748-
require.NoError(t, err)
1749-
require.NotNil(t, ctx)
1750-
require.NotNil(t, cli.Foo)
1751-
require.Equal(t, "wtf", *cli.Foo)
1748+
assert.NoError(t, err)
1749+
assert.NotZero(t, ctx)
1750+
assert.NotZero(t, cli.Foo)
1751+
assert.Equal(t, "wtf", *cli.Foo)
17521752
}
17531753

17541754
func TestStringPointerNoValue(t *testing.T) {
17551755
var cli struct {
17561756
Foo *string
17571757
}
17581758
k, err := kong.New(&cli)
1759-
require.NoError(t, err)
1760-
require.NotNil(t, k)
1759+
assert.NoError(t, err)
1760+
assert.NotZero(t, k)
17611761
ctx, err := k.Parse([]string{})
1762-
require.NoError(t, err)
1763-
require.NotNil(t, ctx)
1764-
require.Nil(t, cli.Foo)
1762+
assert.NoError(t, err)
1763+
assert.NotZero(t, ctx)
1764+
assert.Zero(t, cli.Foo)
17651765
}
17661766

17671767
func TestStringPointerDefault(t *testing.T) {
17681768
var cli struct {
17691769
Foo *string `default:"stuff"`
17701770
}
17711771
k, err := kong.New(&cli)
1772-
require.NoError(t, err)
1773-
require.NotNil(t, k)
1772+
assert.NoError(t, err)
1773+
assert.NotZero(t, k)
17741774
ctx, err := k.Parse([]string{})
1775-
require.NoError(t, err)
1776-
require.NotNil(t, ctx)
1777-
require.NotNil(t, cli.Foo)
1778-
require.Equal(t, "stuff", *cli.Foo)
1775+
assert.NoError(t, err)
1776+
assert.NotZero(t, ctx)
1777+
assert.NotZero(t, cli.Foo)
1778+
assert.Equal(t, "stuff", *cli.Foo)
17791779
}
17801780

17811781
func TestStringPointerAliasNoValue(t *testing.T) {
@@ -1784,12 +1784,12 @@ func TestStringPointerAliasNoValue(t *testing.T) {
17841784
F *Foo
17851785
}
17861786
k, err := kong.New(&cli)
1787-
require.NoError(t, err)
1788-
require.NotNil(t, k)
1787+
assert.NoError(t, err)
1788+
assert.NotZero(t, k)
17891789
ctx, err := k.Parse([]string{})
1790-
require.NoError(t, err)
1791-
require.NotNil(t, ctx)
1792-
require.Nil(t, cli.F)
1790+
assert.NoError(t, err)
1791+
assert.NotZero(t, ctx)
1792+
assert.Zero(t, cli.F)
17931793
}
17941794

17951795
func TestStringPointerAlias(t *testing.T) {
@@ -1798,13 +1798,13 @@ func TestStringPointerAlias(t *testing.T) {
17981798
F *Foo
17991799
}
18001800
k, err := kong.New(&cli)
1801-
require.NoError(t, err)
1802-
require.NotNil(t, k)
1801+
assert.NoError(t, err)
1802+
assert.NotZero(t, k)
18031803
ctx, err := k.Parse([]string{"--f=value"})
1804-
require.NoError(t, err)
1805-
require.NotNil(t, ctx)
1806-
require.NotNil(t, cli.F)
1807-
require.Equal(t, Foo("value"), *cli.F)
1804+
assert.NoError(t, err)
1805+
assert.NotZero(t, ctx)
1806+
assert.NotZero(t, cli.F)
1807+
assert.Equal(t, Foo("value"), *cli.F)
18081808
}
18091809

18101810
func TestStringPointerEmptyValue(t *testing.T) {
@@ -1813,15 +1813,15 @@ func TestStringPointerEmptyValue(t *testing.T) {
18131813
G *string
18141814
}
18151815
k, err := kong.New(&cli)
1816-
require.NoError(t, err)
1817-
require.NotNil(t, k)
1816+
assert.NoError(t, err)
1817+
assert.NotZero(t, k)
18181818
ctx, err := k.Parse([]string{"--f", "", "--g="})
1819-
require.NoError(t, err)
1820-
require.NotNil(t, ctx)
1821-
require.NotNil(t, cli.F)
1822-
require.NotNil(t, cli.G)
1823-
require.Equal(t, "", *cli.F)
1824-
require.Equal(t, "", *cli.G)
1819+
assert.NoError(t, err)
1820+
assert.NotZero(t, ctx)
1821+
assert.NotZero(t, cli.F)
1822+
assert.NotZero(t, cli.G)
1823+
assert.Equal(t, "", *cli.F)
1824+
assert.Equal(t, "", *cli.G)
18251825
}
18261826

18271827
func TestIntPtr(t *testing.T) {
@@ -1830,140 +1830,139 @@ func TestIntPtr(t *testing.T) {
18301830
G *int
18311831
}
18321832
k, err := kong.New(&cli)
1833-
require.NoError(t, err)
1834-
require.NotNil(t, k)
1833+
assert.NoError(t, err)
1834+
assert.NotZero(t, k)
18351835
ctx, err := k.Parse([]string{"--f=6"})
1836-
require.NoError(t, err)
1837-
require.NotNil(t, ctx)
1838-
require.NotNil(t, cli.F)
1839-
require.Nil(t, cli.G)
1840-
require.Equal(t, 6, *cli.F)
1836+
assert.NoError(t, err)
1837+
assert.NotZero(t, ctx)
1838+
assert.NotZero(t, cli.F)
1839+
assert.Zero(t, cli.G)
1840+
assert.Equal(t, 6, *cli.F)
18411841
}
18421842

18431843
func TestBoolPtr(t *testing.T) {
18441844
var cli struct {
18451845
X *bool
18461846
}
18471847
k, err := kong.New(&cli)
1848-
require.NoError(t, err)
1849-
require.NotNil(t, k)
1848+
assert.NoError(t, err)
1849+
assert.NotZero(t, k)
18501850
ctx, err := k.Parse([]string{"--x"})
1851-
require.NoError(t, err)
1852-
require.NotNil(t, ctx)
1853-
require.NotNil(t, cli.X)
1854-
require.Equal(t, true, *cli.X)
1851+
assert.NoError(t, err)
1852+
assert.NotZero(t, ctx)
1853+
assert.NotZero(t, cli.X)
1854+
assert.Equal(t, true, *cli.X)
18551855
}
18561856

18571857
func TestBoolPtrFalse(t *testing.T) {
18581858
var cli struct {
18591859
X *bool
18601860
}
18611861
k, err := kong.New(&cli)
1862-
require.NoError(t, err)
1863-
require.NotNil(t, k)
1862+
assert.NoError(t, err)
1863+
assert.NotZero(t, k)
18641864
ctx, err := k.Parse([]string{"--x=false"})
1865-
require.NoError(t, err)
1866-
require.NotNil(t, ctx)
1867-
require.NotNil(t, cli.X)
1868-
require.Equal(t, false, *cli.X)
1865+
assert.NoError(t, err)
1866+
assert.NotZero(t, ctx)
1867+
assert.NotZero(t, cli.X)
1868+
assert.Equal(t, false, *cli.X)
18691869
}
18701870

18711871
func TestBoolPtrNegated(t *testing.T) {
18721872
var cli struct {
18731873
X *bool `negatable:""`
18741874
}
18751875
k, err := kong.New(&cli)
1876-
require.NoError(t, err)
1877-
require.NotNil(t, k)
1876+
assert.NoError(t, err)
1877+
assert.NotZero(t, k)
18781878
ctx, err := k.Parse([]string{"--no-x"})
1879-
require.NoError(t, err)
1880-
require.NotNil(t, ctx)
1881-
require.NotNil(t, cli.X)
1882-
require.Equal(t, false, *cli.X)
1879+
assert.NoError(t, err)
1880+
assert.NotZero(t, ctx)
1881+
assert.NotZero(t, cli.X)
1882+
assert.Equal(t, false, *cli.X)
18831883
}
18841884

18851885
func TestNilNegatableBoolPtr(t *testing.T) {
18861886
var cli struct {
18871887
X *bool `negatable:""`
18881888
}
18891889
k, err := kong.New(&cli)
1890-
require.NoError(t, err)
1891-
require.NotNil(t, k)
1890+
assert.NoError(t, err)
1891+
assert.NotZero(t, k)
18921892
ctx, err := k.Parse([]string{})
1893-
require.NoError(t, err)
1894-
require.NotNil(t, ctx)
1895-
require.Nil(t, cli.X)
1893+
assert.NoError(t, err)
1894+
assert.NotZero(t, ctx)
1895+
assert.Zero(t, cli.X)
18961896
}
18971897

18981898
func TestBoolPtrNil(t *testing.T) {
18991899
var cli struct {
19001900
X *bool
19011901
}
19021902
k, err := kong.New(&cli)
1903-
require.NoError(t, err)
1904-
require.NotNil(t, k)
1903+
assert.NoError(t, err)
1904+
assert.NotZero(t, k)
19051905
ctx, err := k.Parse([]string{})
1906-
require.NoError(t, err)
1907-
require.NotNil(t, ctx)
1908-
require.Nil(t, cli.X)
1906+
assert.NoError(t, err)
1907+
assert.NotZero(t, ctx)
1908+
assert.Zero(t, cli.X)
19091909
}
19101910

19111911
func TestUnsupportedPtr(t *testing.T) {
1912-
//nolint:structcheck,unused
19131912
type Foo struct {
1914-
x int
1915-
y int
1913+
x int // nolint
1914+
y int // nolint
19161915
}
19171916

19181917
var cli struct {
19191918
F *Foo
19201919
}
19211920
k, err := kong.New(&cli)
1922-
require.NoError(t, err)
1923-
require.NotNil(t, k)
1921+
assert.NoError(t, err)
1922+
assert.NotZero(t, k)
19241923
ctx, err := k.Parse([]string{"--f=whatever"})
1925-
require.Nil(t, ctx)
1926-
require.Error(t, err)
1927-
require.Equal(t, "--f: cannot find mapper for kong_test.Foo", err.Error())
1924+
assert.Zero(t, ctx)
1925+
assert.Error(t, err)
1926+
assert.Equal(t, "--f: cannot find mapper for kong_test.Foo", err.Error())
19281927
}
19291928

19301929
func TestEnumPtr(t *testing.T) {
19311930
var cli struct {
19321931
X *string `enum:"A,B,C" default:"C"`
19331932
}
19341933
k, err := kong.New(&cli)
1935-
require.NoError(t, err)
1936-
require.NotNil(t, k)
1934+
assert.NoError(t, err)
1935+
assert.NotZero(t, k)
19371936
ctx, err := k.Parse([]string{"--x=A"})
1938-
require.NoError(t, err)
1939-
require.NotNil(t, ctx)
1940-
require.NotNil(t, cli.X)
1941-
require.Equal(t, "A", *cli.X)
1937+
assert.NoError(t, err)
1938+
assert.NotZero(t, ctx)
1939+
assert.NotZero(t, cli.X)
1940+
assert.Equal(t, "A", *cli.X)
19421941
}
19431942

19441943
func TestEnumPtrOmitted(t *testing.T) {
19451944
var cli struct {
19461945
X *string `enum:"A,B,C" default:"C"`
19471946
}
19481947
k, err := kong.New(&cli)
1949-
require.NoError(t, err)
1950-
require.NotNil(t, k)
1948+
assert.NoError(t, err)
1949+
assert.NotZero(t, k)
19511950
ctx, err := k.Parse([]string{})
1952-
require.NoError(t, err)
1953-
require.NotNil(t, ctx)
1954-
require.NotNil(t, cli.X)
1955-
require.Equal(t, "C", *cli.X)
1951+
assert.NoError(t, err)
1952+
assert.NotZero(t, ctx)
1953+
assert.NotZero(t, cli.X)
1954+
assert.Equal(t, "C", *cli.X)
19561955
}
19571956

19581957
func TestEnumPtrOmittedNoDefault(t *testing.T) {
19591958
var cli struct {
19601959
X *string `enum:"A,B,C"`
19611960
}
19621961
k, err := kong.New(&cli)
1963-
require.NoError(t, err)
1964-
require.NotNil(t, k)
1962+
assert.NoError(t, err)
1963+
assert.NotZero(t, k)
19651964
ctx, err := k.Parse([]string{})
1966-
require.NoError(t, err)
1967-
require.NotNil(t, ctx)
1968-
require.Nil(t, cli.X)
1965+
assert.NoError(t, err)
1966+
assert.NotZero(t, ctx)
1967+
assert.Zero(t, cli.X)
19691968
}

0 commit comments

Comments
 (0)