Skip to content

Commit 6260b9d

Browse files
jannottijannotti
committed
Stupid linter
1 parent 34d35fd commit 6260b9d

File tree

6 files changed

+92
-94
lines changed

6 files changed

+92
-94
lines changed

‎data/transactions/logic/assembler_test.go

+70-70
Original file line numberDiff line numberDiff line change
@@ -432,7 +432,7 @@ pop
432432
require.Equal(t, ops1.Program, ops2.Program)
433433
}
434434

435-
type expect struct {
435+
type Expect struct {
436436
l int
437437
s string
438438
}
@@ -450,7 +450,7 @@ func testMatch(t testing.TB, actual, expected string) {
450450
}
451451
}
452452

453-
func testProg(t testing.TB, source string, ver uint64, expected ...expect) *OpStream {
453+
func testProg(t testing.TB, source string, ver uint64, expected ...Expect) *OpStream {
454454
t.Helper()
455455
program := strings.ReplaceAll(source, ";", "\n")
456456
ops, err := AssembleStringWithVersion(program, ver)
@@ -521,7 +521,7 @@ func testLine(t *testing.T, line string, ver uint64, expected string) {
521521
testProg(t, source, ver)
522522
return
523523
}
524-
testProg(t, source, ver, expect{2, expected})
524+
testProg(t, source, ver, Expect{2, expected})
525525
}
526526

527527
func TestAssembleTxna(t *testing.T) {
@@ -571,7 +571,7 @@ int 1
571571
+
572572
// comment
573573
`
574-
testProg(t, source, AssemblerMaxVersion, expect{3, "+ arg 0 wanted type uint64 got []byte"})
574+
testProg(t, source, AssemblerMaxVersion, Expect{3, "+ arg 0 wanted type uint64 got []byte"})
575575
}
576576

577577
// mutateProgVersion replaces version (first two symbols) in hex-encoded program
@@ -710,10 +710,10 @@ func TestAssembleBytes(t *testing.T) {
710710
}
711711

712712
for _, b := range bad {
713-
testProg(t, b[0], v, expect{1, b[1]})
713+
testProg(t, b[0], v, Expect{1, b[1]})
714714
// pushbytes should produce the same errors
715715
if v >= 3 {
716-
testProg(t, strings.Replace(b[0], "byte", "pushbytes", 1), v, expect{1, b[1]})
716+
testProg(t, strings.Replace(b[0], "byte", "pushbytes", 1), v, Expect{1, b[1]})
717717
}
718718
}
719719
})
@@ -1182,7 +1182,7 @@ bnz wat
11821182
int 2`
11831183
for v := uint64(1); v < backBranchEnabledVersion; v++ {
11841184
t.Run(fmt.Sprintf("v=%d", v), func(t *testing.T) {
1185-
testProg(t, source, v, expect{3, "label \"wat\" is a back reference..."})
1185+
testProg(t, source, v, Expect{3, "label \"wat\" is a back reference..."})
11861186
})
11871187
}
11881188
for v := uint64(backBranchEnabledVersion); v <= AssemblerMaxVersion; v++ {
@@ -1236,7 +1236,7 @@ bnz nowhere
12361236
int 2`
12371237
for v := uint64(1); v <= AssemblerMaxVersion; v++ {
12381238
t.Run(fmt.Sprintf("v=%d", v), func(t *testing.T) {
1239-
testProg(t, source, v, expect{2, "reference to undefined label \"nowhere\""})
1239+
testProg(t, source, v, Expect{2, "reference to undefined label \"nowhere\""})
12401240
})
12411241
}
12421242
}
@@ -1269,8 +1269,8 @@ int 2`
12691269
for v := uint64(1); v <= AssemblerMaxVersion; v++ {
12701270
t.Run(fmt.Sprintf("v=%d", v), func(t *testing.T) {
12711271
testProg(t, source, v,
1272-
expect{2, "reference to undefined label \"nowhere\""},
1273-
expect{4, "txn unknown field: \"XYZ\""})
1272+
Expect{2, "reference to undefined label \"nowhere\""},
1273+
Expect{4, "txn unknown field: \"XYZ\""})
12741274
})
12751275
}
12761276
}
@@ -1467,15 +1467,15 @@ func TestConstantArgs(t *testing.T) {
14671467
partitiontest.PartitionTest(t)
14681468
t.Parallel()
14691469
for v := uint64(1); v <= AssemblerMaxVersion; v++ {
1470-
testProg(t, "int", v, expect{1, "int needs one argument"})
1471-
testProg(t, "intc", v, expect{1, "intc operation needs one argument"})
1472-
testProg(t, "byte", v, expect{1, "byte operation needs byte literal argument"})
1473-
testProg(t, "bytec", v, expect{1, "bytec operation needs one argument"})
1474-
testProg(t, "addr", v, expect{1, "addr operation needs one argument"})
1470+
testProg(t, "int", v, Expect{1, "int needs one argument"})
1471+
testProg(t, "intc", v, Expect{1, "intc operation needs one argument"})
1472+
testProg(t, "byte", v, Expect{1, "byte operation needs byte literal argument"})
1473+
testProg(t, "bytec", v, Expect{1, "bytec operation needs one argument"})
1474+
testProg(t, "addr", v, Expect{1, "addr operation needs one argument"})
14751475
}
14761476
for v := uint64(3); v <= AssemblerMaxVersion; v++ {
1477-
testProg(t, "pushint", v, expect{1, "pushint needs one argument"})
1478-
testProg(t, "pushbytes", v, expect{1, "pushbytes operation needs byte literal argument"})
1477+
testProg(t, "pushint", v, Expect{1, "pushint needs one argument"})
1478+
testProg(t, "pushbytes", v, Expect{1, "pushbytes operation needs byte literal argument"})
14791479
}
14801480

14811481
}
@@ -1612,7 +1612,7 @@ balance
16121612
int 1
16131613
==`
16141614
for v := uint64(2); v < directRefEnabledVersion; v++ {
1615-
testProg(t, source, v, expect{2, "balance arg 0 wanted type uint64 got []byte"})
1615+
testProg(t, source, v, Expect{2, "balance arg 0 wanted type uint64 got []byte"})
16161616
}
16171617
for v := uint64(directRefEnabledVersion); v <= AssemblerMaxVersion; v++ {
16181618
testProg(t, source, v)
@@ -1629,7 +1629,7 @@ min_balance
16291629
int 1
16301630
==`
16311631
for v := uint64(3); v < directRefEnabledVersion; v++ {
1632-
testProg(t, source, v, expect{2, "min_balance arg 0 wanted type uint64 got []byte"})
1632+
testProg(t, source, v, Expect{2, "min_balance arg 0 wanted type uint64 got []byte"})
16331633
}
16341634
for v := uint64(directRefEnabledVersion); v <= AssemblerMaxVersion; v++ {
16351635
testProg(t, source, v)
@@ -1643,16 +1643,16 @@ func TestAssembleAsset(t *testing.T) {
16431643
introduction := OpsByName[LogicVersion]["asset_holding_get"].Version
16441644
for v := introduction; v <= AssemblerMaxVersion; v++ {
16451645
testProg(t, "asset_holding_get ABC 1", v,
1646-
expect{1, "asset_holding_get ABC 1 expects 2 stack arguments..."})
1646+
Expect{1, "asset_holding_get ABC 1 expects 2 stack arguments..."})
16471647
testProg(t, "int 1; asset_holding_get ABC 1", v,
1648-
expect{2, "asset_holding_get ABC 1 expects 2 stack arguments..."})
1648+
Expect{2, "asset_holding_get ABC 1 expects 2 stack arguments..."})
16491649
testProg(t, "int 1; int 1; asset_holding_get ABC 1", v,
1650-
expect{3, "asset_holding_get expects one argument"})
1650+
Expect{3, "asset_holding_get expects one argument"})
16511651
testProg(t, "int 1; int 1; asset_holding_get ABC", v,
1652-
expect{3, "asset_holding_get unknown field: \"ABC\""})
1652+
Expect{3, "asset_holding_get unknown field: \"ABC\""})
16531653

16541654
testProg(t, "byte 0x1234; asset_params_get ABC 1", v,
1655-
expect{2, "asset_params_get ABC 1 arg 0 wanted type uint64..."})
1655+
Expect{2, "asset_params_get ABC 1 arg 0 wanted type uint64..."})
16561656

16571657
testLine(t, "asset_params_get ABC 1", v, "asset_params_get expects one argument")
16581658
testLine(t, "asset_params_get ABC", v, "asset_params_get unknown field: \"ABC\"")
@@ -2036,15 +2036,15 @@ func TestPragmas(t *testing.T) {
20362036
}
20372037

20382038
testProg(t, `#pragma version 100`, assemblerNoVersion,
2039-
expect{1, "unsupported version: 100"})
2039+
Expect{1, "unsupported version: 100"})
20402040

2041-
testProg(t, `int 1`, 99, expect{0, "Can not assemble version 99"})
2041+
testProg(t, `int 1`, 99, Expect{0, "Can not assemble version 99"})
20422042

20432043
// Allow this on the off chance someone needs to reassemble an old logigsig
20442044
testProg(t, `#pragma version 0`, assemblerNoVersion)
20452045

20462046
testProg(t, `#pragma version a`, assemblerNoVersion,
2047-
expect{1, `bad #pragma version: "a"`})
2047+
Expect{1, `bad #pragma version: "a"`})
20482048

20492049
// will default to 1
20502050
ops := testProg(t, "int 3", assemblerNoVersion)
@@ -2058,35 +2058,35 @@ func TestPragmas(t *testing.T) {
20582058
require.Equal(t, uint64(2), ops.Version)
20592059

20602060
// changing version is not allowed
2061-
testProg(t, "#pragma version 1", 2, expect{1, "version mismatch..."})
2062-
testProg(t, "#pragma version 2", 1, expect{1, "version mismatch..."})
2061+
testProg(t, "#pragma version 1", 2, Expect{1, "version mismatch..."})
2062+
testProg(t, "#pragma version 2", 1, Expect{1, "version mismatch..."})
20632063

20642064
testProg(t, "#pragma version 2\n#pragma version 1", assemblerNoVersion,
2065-
expect{2, "version mismatch..."})
2065+
Expect{2, "version mismatch..."})
20662066

20672067
// repetitive, but fine
20682068
ops = testProg(t, "#pragma version 2\n#pragma version 2", assemblerNoVersion)
20692069
require.Equal(t, uint64(2), ops.Version)
20702070

20712071
testProg(t, "\nint 1\n#pragma version 2", assemblerNoVersion,
2072-
expect{3, "#pragma version is only allowed before instructions"})
2072+
Expect{3, "#pragma version is only allowed before instructions"})
20732073

20742074
testProg(t, "#pragma run-mode 2", assemblerNoVersion,
2075-
expect{1, `unsupported pragma directive: "run-mode"`})
2075+
Expect{1, `unsupported pragma directive: "run-mode"`})
20762076

20772077
testProg(t, "#pragma versions", assemblerNoVersion,
2078-
expect{1, `unsupported pragma directive: "versions"`})
2078+
Expect{1, `unsupported pragma directive: "versions"`})
20792079

20802080
ops = testProg(t, "#pragma version 1", assemblerNoVersion)
20812081
require.Equal(t, uint64(1), ops.Version)
20822082

20832083
ops = testProg(t, "\n#pragma version 1", assemblerNoVersion)
20842084
require.Equal(t, uint64(1), ops.Version)
20852085

2086-
testProg(t, "#pragma", assemblerNoVersion, expect{1, "empty pragma"})
2086+
testProg(t, "#pragma", assemblerNoVersion, Expect{1, "empty pragma"})
20872087

20882088
testProg(t, "#pragma version", assemblerNoVersion,
2089-
expect{1, "no version value"})
2089+
Expect{1, "no version value"})
20902090

20912091
ops = testProg(t, " #pragma version 5 ", assemblerNoVersion)
20922092
require.Equal(t, uint64(5), ops.Version)
@@ -2105,8 +2105,8 @@ int 1
21052105
require.NoError(t, err)
21062106
require.Equal(t, ops1.Program, ops.Program)
21072107

2108-
testProg(t, text, 0, expect{1, "version mismatch..."})
2109-
testProg(t, text, 2, expect{1, "version mismatch..."})
2108+
testProg(t, text, 0, Expect{1, "version mismatch..."})
2109+
testProg(t, text, 2, Expect{1, "version mismatch..."})
21102110
testProg(t, text, assemblerNoVersion)
21112111

21122112
ops, err = AssembleStringWithVersion(text, assemblerNoVersion)
@@ -2122,8 +2122,8 @@ int 1
21222122
require.NoError(t, err)
21232123
require.Equal(t, ops2.Program, ops.Program)
21242124

2125-
testProg(t, text, 0, expect{1, "version mismatch..."})
2126-
testProg(t, text, 1, expect{1, "version mismatch..."})
2125+
testProg(t, text, 0, Expect{1, "version mismatch..."})
2126+
testProg(t, text, 1, Expect{1, "version mismatch..."})
21272127

21282128
ops, err = AssembleStringWithVersion(text, assemblerNoVersion)
21292129
require.NoError(t, err)
@@ -2143,7 +2143,7 @@ len
21432143
require.Equal(t, ops2.Program, ops.Program)
21442144

21452145
testProg(t, "#pragma unk", assemblerNoVersion,
2146-
expect{1, `unsupported pragma directive: "unk"`})
2146+
Expect{1, `unsupported pragma directive: "unk"`})
21472147
}
21482148

21492149
func TestAssembleConstants(t *testing.T) {
@@ -2215,77 +2215,77 @@ func TestSwapTypeCheck(t *testing.T) {
22152215
partitiontest.PartitionTest(t)
22162216
t.Parallel()
22172217
/* reconfirm that we detect this type error */
2218-
testProg(t, "int 1; byte 0x1234; +", AssemblerMaxVersion, expect{3, "+ arg 1..."})
2218+
testProg(t, "int 1; byte 0x1234; +", AssemblerMaxVersion, Expect{3, "+ arg 1..."})
22192219
/* despite swap, we track types */
2220-
testProg(t, "int 1; byte 0x1234; swap; +", AssemblerMaxVersion, expect{4, "+ arg 0..."})
2221-
testProg(t, "byte 0x1234; int 1; swap; +", AssemblerMaxVersion, expect{4, "+ arg 1..."})
2220+
testProg(t, "int 1; byte 0x1234; swap; +", AssemblerMaxVersion, Expect{4, "+ arg 0..."})
2221+
testProg(t, "byte 0x1234; int 1; swap; +", AssemblerMaxVersion, Expect{4, "+ arg 1..."})
22222222
}
22232223

22242224
func TestDigAsm(t *testing.T) {
22252225
partitiontest.PartitionTest(t)
22262226
t.Parallel()
2227-
testProg(t, "int 1; dig; +", AssemblerMaxVersion, expect{2, "dig expects 1 immediate..."})
2228-
testProg(t, "int 1; dig junk; +", AssemblerMaxVersion, expect{2, "dig unable to parse..."})
2227+
testProg(t, "int 1; dig; +", AssemblerMaxVersion, Expect{2, "dig expects 1 immediate..."})
2228+
testProg(t, "int 1; dig junk; +", AssemblerMaxVersion, Expect{2, "dig unable to parse..."})
22292229

22302230
testProg(t, "int 1; byte 0x1234; int 2; dig 2; +", AssemblerMaxVersion)
22312231
testProg(t, "byte 0x32; byte 0x1234; int 2; dig 2; +", AssemblerMaxVersion,
2232-
expect{5, "+ arg 1..."})
2232+
Expect{5, "+ arg 1..."})
22332233
testProg(t, "byte 0x32; byte 0x1234; int 2; dig 3; +", AssemblerMaxVersion,
2234-
expect{4, "dig 3 expects 4..."})
2234+
Expect{4, "dig 3 expects 4..."})
22352235
testProg(t, "int 1; byte 0x1234; int 2; dig 12; +", AssemblerMaxVersion,
2236-
expect{4, "dig 12 expects 13..."})
2236+
Expect{4, "dig 12 expects 13..."})
22372237

22382238
// Confirm that digging something out does not ruin our knowledge about the types in the middle
22392239
testProg(t, "int 1; byte 0x1234; byte 0x1234; dig 2; dig 3; +; pop; +", AssemblerMaxVersion,
2240-
expect{8, "+ arg 1..."})
2240+
Expect{8, "+ arg 1..."})
22412241
testProg(t, "int 3; pushbytes \"123456\"; int 1; dig 2; substring3", AssemblerMaxVersion)
22422242

22432243
}
22442244

22452245
func TestEqualsTypeCheck(t *testing.T) {
22462246
partitiontest.PartitionTest(t)
22472247
t.Parallel()
2248-
testProg(t, "int 1; byte 0x1234; ==", AssemblerMaxVersion, expect{3, "== arg 0..."})
2249-
testProg(t, "int 1; byte 0x1234; !=", AssemblerMaxVersion, expect{3, "!= arg 0..."})
2250-
testProg(t, "byte 0x1234; int 1; ==", AssemblerMaxVersion, expect{3, "== arg 0..."})
2251-
testProg(t, "byte 0x1234; int 1; !=", AssemblerMaxVersion, expect{3, "!= arg 0..."})
2248+
testProg(t, "int 1; byte 0x1234; ==", AssemblerMaxVersion, Expect{3, "== arg 0..."})
2249+
testProg(t, "int 1; byte 0x1234; !=", AssemblerMaxVersion, Expect{3, "!= arg 0..."})
2250+
testProg(t, "byte 0x1234; int 1; ==", AssemblerMaxVersion, Expect{3, "== arg 0..."})
2251+
testProg(t, "byte 0x1234; int 1; !=", AssemblerMaxVersion, Expect{3, "!= arg 0..."})
22522252
}
22532253

22542254
func TestDupTypeCheck(t *testing.T) {
22552255
partitiontest.PartitionTest(t)
22562256
t.Parallel()
2257-
testProg(t, "byte 0x1234; dup; int 1; +", AssemblerMaxVersion, expect{4, "+ arg 0..."})
2257+
testProg(t, "byte 0x1234; dup; int 1; +", AssemblerMaxVersion, Expect{4, "+ arg 0..."})
22582258
testProg(t, "byte 0x1234; int 1; dup; +", AssemblerMaxVersion)
2259-
testProg(t, "byte 0x1234; int 1; dup2; +", AssemblerMaxVersion, expect{4, "+ arg 0..."})
2260-
testProg(t, "int 1; byte 0x1234; dup2; +", AssemblerMaxVersion, expect{4, "+ arg 1..."})
2259+
testProg(t, "byte 0x1234; int 1; dup2; +", AssemblerMaxVersion, Expect{4, "+ arg 0..."})
2260+
testProg(t, "int 1; byte 0x1234; dup2; +", AssemblerMaxVersion, Expect{4, "+ arg 1..."})
22612261

2262-
testProg(t, "byte 0x1234; int 1; dup; dig 1; len", AssemblerMaxVersion, expect{5, "len arg 0..."})
2263-
testProg(t, "int 1; byte 0x1234; dup; dig 1; !", AssemblerMaxVersion, expect{5, "! arg 0..."})
2262+
testProg(t, "byte 0x1234; int 1; dup; dig 1; len", AssemblerMaxVersion, Expect{5, "len arg 0..."})
2263+
testProg(t, "int 1; byte 0x1234; dup; dig 1; !", AssemblerMaxVersion, Expect{5, "! arg 0..."})
22642264

2265-
testProg(t, "byte 0x1234; int 1; dup2; dig 2; len", AssemblerMaxVersion, expect{5, "len arg 0..."})
2266-
testProg(t, "int 1; byte 0x1234; dup2; dig 2; !", AssemblerMaxVersion, expect{5, "! arg 0..."})
2265+
testProg(t, "byte 0x1234; int 1; dup2; dig 2; len", AssemblerMaxVersion, Expect{5, "len arg 0..."})
2266+
testProg(t, "int 1; byte 0x1234; dup2; dig 2; !", AssemblerMaxVersion, Expect{5, "! arg 0..."})
22672267
}
22682268

22692269
func TestSelectTypeCheck(t *testing.T) {
22702270
partitiontest.PartitionTest(t)
22712271
t.Parallel()
2272-
testProg(t, "int 1; int 2; int 3; select; len", AssemblerMaxVersion, expect{5, "len arg 0..."})
2273-
testProg(t, "byte 0x1234; byte 0x5678; int 3; select; !", AssemblerMaxVersion, expect{5, "! arg 0..."})
2272+
testProg(t, "int 1; int 2; int 3; select; len", AssemblerMaxVersion, Expect{5, "len arg 0..."})
2273+
testProg(t, "byte 0x1234; byte 0x5678; int 3; select; !", AssemblerMaxVersion, Expect{5, "! arg 0..."})
22742274
}
22752275

22762276
func TestSetBitTypeCheck(t *testing.T) {
22772277
partitiontest.PartitionTest(t)
22782278
t.Parallel()
2279-
testProg(t, "int 1; int 2; int 3; setbit; len", AssemblerMaxVersion, expect{5, "len arg 0..."})
2280-
testProg(t, "byte 0x1234; int 2; int 3; setbit; !", AssemblerMaxVersion, expect{5, "! arg 0..."})
2279+
testProg(t, "int 1; int 2; int 3; setbit; len", AssemblerMaxVersion, Expect{5, "len arg 0..."})
2280+
testProg(t, "byte 0x1234; int 2; int 3; setbit; !", AssemblerMaxVersion, Expect{5, "! arg 0..."})
22812281
}
22822282

22832283
func TestCoverAsm(t *testing.T) {
22842284
partitiontest.PartitionTest(t)
22852285
t.Parallel()
22862286
testProg(t, `int 4; byte "john"; int 5; cover 2; pop; +`, AssemblerMaxVersion)
22872287
testProg(t, `int 4; byte "ayush"; int 5; cover 1; pop; +`, AssemblerMaxVersion)
2288-
testProg(t, `int 4; byte "john"; int 5; cover 2; +`, AssemblerMaxVersion, expect{5, "+ arg 1..."})
2288+
testProg(t, `int 4; byte "john"; int 5; cover 2; +`, AssemblerMaxVersion, Expect{5, "+ arg 1..."})
22892289

22902290
}
22912291

@@ -2295,15 +2295,15 @@ func TestUncoverAsm(t *testing.T) {
22952295
testProg(t, `int 4; byte "john"; int 5; uncover 2; +`, AssemblerMaxVersion)
22962296
testProg(t, `int 4; byte "ayush"; int 5; uncover 1; pop; +`, AssemblerMaxVersion)
22972297
testProg(t, `int 1; byte "jj"; byte "ayush"; byte "john"; int 5; uncover 4; +`, AssemblerMaxVersion)
2298-
testProg(t, `int 4; byte "ayush"; int 5; uncover 1; +`, AssemblerMaxVersion, expect{5, "+ arg 1..."})
2298+
testProg(t, `int 4; byte "ayush"; int 5; uncover 1; +`, AssemblerMaxVersion, Expect{5, "+ arg 1..."})
22992299
}
23002300

23012301
func TestTxTypes(t *testing.T) {
2302-
testProg(t, "itxn_begin; itxn_field Sender", 5, expect{2, "itxn_field Sender expects 1 stack argument..."})
2303-
testProg(t, "itxn_begin; int 1; itxn_field Sender", 5, expect{3, "...wanted type []byte got uint64"})
2302+
testProg(t, "itxn_begin; itxn_field Sender", 5, Expect{2, "itxn_field Sender expects 1 stack argument..."})
2303+
testProg(t, "itxn_begin; int 1; itxn_field Sender", 5, Expect{3, "...wanted type []byte got uint64"})
23042304
testProg(t, "itxn_begin; byte 0x56127823; itxn_field Sender", 5)
23052305

2306-
testProg(t, "itxn_begin; itxn_field Amount", 5, expect{2, "itxn_field Amount expects 1 stack argument..."})
2307-
testProg(t, "itxn_begin; byte 0x87123376; itxn_field Amount", 5, expect{3, "...wanted type uint64 got []byte"})
2306+
testProg(t, "itxn_begin; itxn_field Amount", 5, Expect{2, "itxn_field Amount expects 1 stack argument..."})
2307+
testProg(t, "itxn_begin; byte 0x87123376; itxn_field Amount", 5, Expect{3, "...wanted type uint64 got []byte"})
23082308
testProg(t, "itxn_begin; int 1; itxn_field Amount", 5)
23092309
}

‎data/transactions/logic/backwardCompat_test.go

+3-3
Original file line numberDiff line numberDiff line change
@@ -468,15 +468,15 @@ func TestBackwardCompatAssemble(t *testing.T) {
468468
source := "int 1; int 1; bnz done; done:"
469469

470470
t.Run("v=default", func(t *testing.T) {
471-
testProg(t, source, assemblerNoVersion, expect{4, "label \"done\" is too far away"})
471+
testProg(t, source, assemblerNoVersion, Expect{4, "label \"done\" is too far away"})
472472
})
473473

474474
t.Run("v=default", func(t *testing.T) {
475-
testProg(t, source, 0, expect{4, "label \"done\" is too far away"})
475+
testProg(t, source, 0, Expect{4, "label \"done\" is too far away"})
476476
})
477477

478478
t.Run("v=default", func(t *testing.T) {
479-
testProg(t, source, 1, expect{4, "label \"done\" is too far away"})
479+
testProg(t, source, 1, Expect{4, "label \"done\" is too far away"})
480480
})
481481

482482
for v := uint64(2); v <= AssemblerMaxVersion; v++ {

0 commit comments

Comments
 (0)