diff --git a/runtime/convertValues_test.go b/runtime/convertValues_test.go index dd61b4017d..ff2c15a0f1 100644 --- a/runtime/convertValues_test.go +++ b/runtime/convertValues_test.go @@ -2099,25 +2099,27 @@ func TestRuntimeEnumValue(t *testing.T) { } func executeTestScript(t *testing.T, script string, arg cadence.Value) (cadence.Value, error) { - encodedArg, err := json.Encode(arg) - require.NoError(t, err) - rt := newTestInterpreterRuntime() - storage := newTestLedger(nil, nil) - runtimeInterface := &testRuntimeInterface{ - storage: storage, + storage: newTestLedger(nil, nil), decodeArgument: func(b []byte, t cadence.Type) (value cadence.Value, err error) { return json.Decode(b) }, } + scriptParam := Script{ + Source: []byte(script), + } + + if arg != nil { + encodedArg, err := json.Encode(arg) + require.NoError(t, err) + scriptParam.Arguments = [][]byte{encodedArg} + } + return rt.ExecuteScript( - Script{ - Source: []byte(script), - Arguments: [][]byte{encodedArg}, - }, + scriptParam, Context{ Interface: runtimeInterface, Location: TestLocation, diff --git a/runtime/parser2/parser_test.go b/runtime/parser2/parser_test.go index 9dc830214b..919a02c4e1 100644 --- a/runtime/parser2/parser_test.go +++ b/runtime/parser2/parser_test.go @@ -37,11 +37,28 @@ func TestMain(m *testing.M) { } func TestParseInvalid(t *testing.T) { - t.Parallel() - _, err := ParseProgram("X") - require.EqualError(t, err, "Parsing failed:\nerror: unexpected token: identifier\n --> :1:0\n |\n1 | X\n | ^\n") + type test struct { + msg string + code string + } + + unexpectedToken := "Parsing failed:\nerror: unexpected token: identifier" + expectedExpression := "Parsing failed:\nerror: expected expression" + missingTypeAnnotation := "Parsing failed:\nerror: missing type annotation after comma" + + for _, test := range []test{ + {unexpectedToken, "X"}, + {unexpectedToken, "paste your code in here"}, + {expectedExpression, "# a ( b > c > d > e > f > g > h > i > j > k > l > m > n > o > p > q > r > s > t > u > v > w > x > y > z > A > B > C > D > E > F>"}, + {missingTypeAnnotation, "#0x0<{},>()"}, + } { + t.Run(test.code, func(t *testing.T) { + _, err := ParseProgram(test.code) + require.ErrorContains(t, err, test.msg) + }) + } } func TestParseBuffering(t *testing.T) { diff --git a/runtime/tests/checker/casting_test.go b/runtime/tests/checker/casting_test.go index 646a0fbab6..232cdbd270 100644 --- a/runtime/tests/checker/casting_test.go +++ b/runtime/tests/checker/casting_test.go @@ -6676,3 +6676,24 @@ func TestCheckUnnecessaryCasts(t *testing.T) { }) }) } + +func TestCastResourceAsEnumAsEmptyDict(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "resource as { enum x : as { } }") + + errs := ExpectCheckerErrors(t, err, 2) + + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0]) + assert.IsType(t, &sema.InvalidEnumRawTypeError{}, errs[1]) +} + +// + +func TestCastNumbersManyTimesThenGetType(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "let a = 0x0 as UInt64!as?UInt64!as?UInt64?!?.getType()") + + assert.Nil(t, err) +} diff --git a/runtime/tests/checker/contract_test.go b/runtime/tests/checker/contract_test.go index ed8a7a308a..09b999b807 100644 --- a/runtime/tests/checker/contract_test.go +++ b/runtime/tests/checker/contract_test.go @@ -708,3 +708,43 @@ func TestCheckInvalidContractNestedTypeShadowing(t *testing.T) { }) } } + +func TestCheckBadContractNesting(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "contract signatureAlgorithm { resource interface payer { contract fun : payer { contract fun { contract fun { } contract fun { contract interface account { } } contract account { } } } } }") + + errs := ExpectCheckerErrors(t, err, 14) + + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1]) + assert.IsType(t, &sema.RedeclarationError{}, errs[2]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[3]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[5]) + assert.IsType(t, &sema.RedeclarationError{}, errs[6]) + assert.IsType(t, &sema.RedeclarationError{}, errs[7]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[8]) + assert.IsType(t, &sema.RedeclarationError{}, errs[9]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[10]) + assert.IsType(t, &sema.MissingConformanceError{}, errs[11]) + assert.IsType(t, &sema.RedeclarationError{}, errs[12]) + assert.IsType(t, &sema.RedeclarationError{}, errs[13]) +} + +func TestCheckContractEnumAccessRestricted(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheckWithOptions(t, "contract enum{}let x = enum!", + ParseAndCheckOptions{ + Options: []sema.Option{ + sema.WithAccessCheckMode(sema.AccessCheckModeStrict), + }, + }, + ) + + errs := ExpectCheckerErrors(t, err, 2) + + assert.IsType(t, &sema.MissingAccessModifierError{}, errs[0]) + assert.IsType(t, &sema.MissingAccessModifierError{}, errs[1]) +} diff --git a/runtime/tests/checker/declaration_test.go b/runtime/tests/checker/declaration_test.go index aaf08feade..11083c88f7 100644 --- a/runtime/tests/checker/declaration_test.go +++ b/runtime/tests/checker/declaration_test.go @@ -677,3 +677,37 @@ func TestCheckBuiltinRedeclaration(t *testing.T) { }, ) } + +func TestCheckUint64RedeclarationFails(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "let UInt64 = UInt64 ( 0b0 )") + + errs := ExpectCheckerErrors(t, err, 1) + + assert.IsType(t, &sema.RedeclarationError{}, errs[0]) +} + +func TestCheckTypeRedeclarationFails(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "let Type = Type") + + errs := ExpectCheckerErrors(t, err, 1) + + assert.IsType(t, &sema.RedeclarationError{}, errs[0]) +} + +func TestCheckSetToTypeList(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "var a=[Type]") + assert.Nil(t, err) +} + +func TestCheckSetToDictWithType(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "var j={0.0:Type}") + assert.Nil(t, err) +} diff --git a/runtime/tests/checker/interface_test.go b/runtime/tests/checker/interface_test.go index 10812e4d90..30fd655e77 100644 --- a/runtime/tests/checker/interface_test.go +++ b/runtime/tests/checker/interface_test.go @@ -1991,3 +1991,24 @@ func TestCheckInvalidInterfaceUseAsTypeSuggestion(t *testing.T) { errs[0].(*sema.InvalidInterfaceTypeError).ExpectedType, ) } + +func TestCheckBadStructInterface(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "struct interface var { contract h : var { contract h { } contract h { contract h { } } } }") + + errs := ExpectCheckerErrors(t, err, 12) + + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[2]) + assert.IsType(t, &sema.RedeclarationError{}, errs[3]) + assert.IsType(t, &sema.RedeclarationError{}, errs[4]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[5]) + assert.IsType(t, &sema.RedeclarationError{}, errs[6]) + assert.IsType(t, &sema.RedeclarationError{}, errs[7]) + assert.IsType(t, &sema.RedeclarationError{}, errs[8]) + assert.IsType(t, &sema.RedeclarationError{}, errs[9]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[10]) + assert.IsType(t, &sema.RedeclarationError{}, errs[11]) +} diff --git a/runtime/tests/checker/nesting_test.go b/runtime/tests/checker/nesting_test.go index c66414b52b..d146472399 100644 --- a/runtime/tests/checker/nesting_test.go +++ b/runtime/tests/checker/nesting_test.go @@ -323,3 +323,13 @@ func TestCheckNestedTypeInvalidChildType(t *testing.T) { }) } } + +func TestCheckNestedTypeUnsupportedPublicKey(t *testing.T) { + t.Parallel() + + _, err := ParseAndCheck(t, "let b=0.0as!PublicKey.Contracts") + + errs := ExpectCheckerErrors(t, err, 1) + + assert.IsType(t, &sema.InvalidNestedTypeError{}, errs[0]) +} diff --git a/runtime/tests/checker/resources_test.go b/runtime/tests/checker/resources_test.go index c9ae20df57..21a32a58f7 100644 --- a/runtime/tests/checker/resources_test.go +++ b/runtime/tests/checker/resources_test.go @@ -8616,3 +8616,64 @@ func TestCheckResourceInvalidationWithConditionalExprInDestroy(t *testing.T) { assert.IsType(t, &sema.InvalidConditionalResourceOperandError{}, errs[0]) assert.IsType(t, &sema.InvalidConditionalResourceOperandError{}, errs[1]) } + +func TestCheckBadResourceInterface(t *testing.T) { + t.Parallel() + + t.Run("bad resource interface: shorter", func(t *testing.T) { + + _, err := ParseAndCheck(t, "resource interface struct{struct d:struct{ struct d:struct{ }struct d:struct{ struct d:struct{ }}}}") + + errs := ExpectCheckerErrors(t, err, 17) + + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1]) + assert.IsType(t, &sema.RedeclarationError{}, errs[2]) + assert.IsType(t, &sema.RedeclarationError{}, errs[3]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4]) + assert.IsType(t, &sema.RedeclarationError{}, errs[5]) + assert.IsType(t, &sema.RedeclarationError{}, errs[6]) + assert.IsType(t, &sema.RedeclarationError{}, errs[7]) + assert.IsType(t, &sema.RedeclarationError{}, errs[8]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[9]) + assert.IsType(t, &sema.RedeclarationError{}, errs[10]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[11]) + assert.IsType(t, &sema.ConformanceError{}, errs[12]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[13]) + assert.IsType(t, &sema.ConformanceError{}, errs[14]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[15]) + assert.IsType(t, &sema.ConformanceError{}, errs[16]) + }) + + t.Run("bad resource interface: longer", func(t *testing.T) { + + _, err := ParseAndCheck(t, "resource interface struct{struct d:struct{ contract d:struct{ contract x:struct{ struct d{} contract d:struct{ contract d:struct {}}}}}}") + + errs := ExpectCheckerErrors(t, err, 24) + + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[0]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[1]) + assert.IsType(t, &sema.RedeclarationError{}, errs[2]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[3]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[4]) + assert.IsType(t, &sema.RedeclarationError{}, errs[5]) + assert.IsType(t, &sema.RedeclarationError{}, errs[6]) + assert.IsType(t, &sema.InvalidNestedDeclarationError{}, errs[7]) + assert.IsType(t, &sema.RedeclarationError{}, errs[8]) + assert.IsType(t, &sema.RedeclarationError{}, errs[9]) + assert.IsType(t, &sema.RedeclarationError{}, errs[10]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[11]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[12]) + assert.IsType(t, &sema.ConformanceError{}, errs[13]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[14]) + assert.IsType(t, &sema.ConformanceError{}, errs[15]) + assert.IsType(t, &sema.RedeclarationError{}, errs[16]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[17]) + assert.IsType(t, &sema.RedeclarationError{}, errs[18]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[19]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[20]) + assert.IsType(t, &sema.ConformanceError{}, errs[21]) + assert.IsType(t, &sema.CompositeKindMismatchError{}, errs[22]) + assert.IsType(t, &sema.ConformanceError{}, errs[23]) + }) +}