Skip to content

Commit ec67687

Browse files
dhildhil
committed
[rpc] State override assertion violation tests
1 parent f4d8945 commit ec67687

File tree

1 file changed

+392
-0
lines changed

1 file changed

+392
-0
lines changed

‎category/rpc/monad_executor_test.cpp‎

Lines changed: 392 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3505,3 +3505,395 @@ TEST_F(EthCallFixture, prestate_override_state)
35053505

35063506
monad_executor_destroy(executor);
35073507
}
3508+
3509+
// Google recommends using the "DeathTest" prefix (c.f.
3510+
// https://google.github.io/googletest/advanced.html#death-test-naming); such
3511+
// tests are specially recognized by the Gtest framework to run before any other
3512+
// tests within the same suite because they're implemented using fork(), and as
3513+
// such, don't play nicely in a multi-threaded environment.
3514+
using EthCallFixtureDeathTest = EthCallFixture;
3515+
3516+
TEST_F(EthCallFixtureDeathTest, state_override_garbage)
3517+
{
3518+
static constexpr Address ADDR_A =
3519+
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_address;
3520+
static constexpr Address ADDR_B =
3521+
0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb_address;
3522+
3523+
auto *state_override = monad_state_override_create();
3524+
3525+
// Test 0: Null state override object
3526+
EXPECT_DEATH(
3527+
add_override_address(nullptr, ADDR_A.bytes, sizeof(Address)),
3528+
"Assertion 'm' failed");
3529+
3530+
// Test 1: Null address
3531+
EXPECT_DEATH(
3532+
add_override_address(state_override, nullptr, sizeof(Address)),
3533+
"Assertion 'addr' failed");
3534+
3535+
EXPECT_DEATH(
3536+
set_override_balance(
3537+
state_override,
3538+
nullptr,
3539+
sizeof(Address),
3540+
(0xABCD_bytes32).bytes,
3541+
sizeof(bytes32_t)),
3542+
"Assertion 'addr' failed");
3543+
3544+
EXPECT_DEATH(
3545+
set_override_nonce(state_override, nullptr, sizeof(Address), 42),
3546+
"Assertion 'addr' failed");
3547+
3548+
{
3549+
evmc::bytes const code = evmc::from_hex("0x00").value();
3550+
EXPECT_DEATH(
3551+
set_override_code(
3552+
state_override,
3553+
nullptr,
3554+
sizeof(Address),
3555+
code.data(),
3556+
code.size()),
3557+
"Assertion 'addr' failed");
3558+
}
3559+
3560+
EXPECT_DEATH(
3561+
set_override_state(
3562+
state_override,
3563+
nullptr,
3564+
sizeof(Address),
3565+
(0xABCD_bytes32).bytes,
3566+
sizeof(bytes32_t),
3567+
(0x1234_bytes32).bytes,
3568+
sizeof(bytes32_t)),
3569+
"Assertion 'addr' failed");
3570+
3571+
EXPECT_DEATH(
3572+
set_override_state_diff(
3573+
state_override,
3574+
nullptr,
3575+
sizeof(Address),
3576+
(0xABCD_bytes32).bytes,
3577+
sizeof(bytes32_t),
3578+
(0x1234_bytes32).bytes,
3579+
sizeof(bytes32_t)),
3580+
"Assertion 'addr' failed");
3581+
3582+
// Test 2: Bad address length
3583+
{
3584+
evmc::bytes const code = evmc::from_hex("0x00").value();
3585+
for (size_t len = 1; len < 1024; len *= 2) {
3586+
uint8_t *bad_address = new uint8_t[len];
3587+
3588+
EXPECT_DEATH(
3589+
add_override_address(state_override, bad_address, len),
3590+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3591+
3592+
EXPECT_DEATH(
3593+
set_override_balance(
3594+
state_override,
3595+
bad_address,
3596+
len,
3597+
(0xABCD_bytes32).bytes,
3598+
sizeof(bytes32_t)),
3599+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3600+
3601+
EXPECT_DEATH(
3602+
set_override_nonce(state_override, bad_address, len, 42),
3603+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3604+
3605+
EXPECT_DEATH(
3606+
set_override_code(
3607+
state_override, bad_address, len, code.data(), code.size()),
3608+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3609+
3610+
EXPECT_DEATH(
3611+
set_override_state(
3612+
state_override,
3613+
bad_address,
3614+
len,
3615+
(0xABCD_bytes32).bytes,
3616+
sizeof(bytes32_t),
3617+
(0x1234_bytes32).bytes,
3618+
sizeof(bytes32_t)),
3619+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3620+
3621+
EXPECT_DEATH(
3622+
set_override_state_diff(
3623+
state_override,
3624+
bad_address,
3625+
len,
3626+
(0xABCD_bytes32).bytes,
3627+
sizeof(bytes32_t),
3628+
(0x1234_bytes32).bytes,
3629+
sizeof(bytes32_t)),
3630+
"Assertion 'addr_len == sizeof\\(Address\\)' failed");
3631+
3632+
delete[] bad_address;
3633+
}
3634+
}
3635+
3636+
add_override_address(state_override, ADDR_A.bytes, sizeof(Address));
3637+
3638+
// Test 3: Null balance pointer
3639+
EXPECT_DEATH(
3640+
set_override_balance(
3641+
state_override,
3642+
ADDR_A.bytes,
3643+
sizeof(Address),
3644+
nullptr,
3645+
sizeof(bytes32_t)),
3646+
"Assertion 'balance' failed");
3647+
3648+
// Test 4: Bad balance length
3649+
for (size_t len = 1; len < 1024; len *= 2) {
3650+
if (len == sizeof(uint256_t)) {
3651+
continue;
3652+
}
3653+
uint8_t *balance = new uint8_t[len];
3654+
EXPECT_DEATH(
3655+
set_override_balance(
3656+
state_override, ADDR_A.bytes, sizeof(Address), balance, len),
3657+
"Assertion 'balance_len == sizeof\\(uint256_t\\)' failed");
3658+
delete[] balance;
3659+
}
3660+
3661+
// Test 5: set balance on nonexistent address
3662+
EXPECT_DEATH(
3663+
set_override_balance(
3664+
state_override,
3665+
ADDR_B.bytes,
3666+
sizeof(Address),
3667+
(0xABCD_bytes32).bytes,
3668+
sizeof(bytes32_t)),
3669+
"Assertion 'm->override_sets\\.find\\(address\\) != "
3670+
"m->override_sets\\.end\\(\\)' failed");
3671+
3672+
// Test 6: set nonce on nonexistent address
3673+
EXPECT_DEATH(
3674+
set_override_nonce(state_override, ADDR_B.bytes, sizeof(Address), 42),
3675+
"Assertion 'm->override_sets\\.find\\(address\\) != "
3676+
"m->override_sets\\.end\\(\\)' failed");
3677+
3678+
// Test 7: set code on nonexistent address
3679+
{
3680+
evmc::bytes const code = evmc::from_hex("0x00").value();
3681+
EXPECT_DEATH(
3682+
set_override_code(
3683+
state_override,
3684+
ADDR_B.bytes,
3685+
sizeof(Address),
3686+
code.data(),
3687+
code.size()),
3688+
"Assertion 'm->override_sets\\.find\\(address\\) != "
3689+
"m->override_sets\\.end\\(\\)' failed");
3690+
}
3691+
3692+
// Test 8: Null code pointer
3693+
{
3694+
EXPECT_DEATH(
3695+
set_override_code(
3696+
state_override, ADDR_A.bytes, sizeof(Address), nullptr, 2),
3697+
"Assertion 'code' failed");
3698+
}
3699+
3700+
// Test 9: set state diff on nonexistent address
3701+
EXPECT_DEATH(
3702+
set_override_state_diff(
3703+
state_override,
3704+
ADDR_B.bytes,
3705+
sizeof(Address),
3706+
(0xABCD_bytes32).bytes,
3707+
sizeof(bytes32_t),
3708+
(0x1234_bytes32).bytes,
3709+
sizeof(bytes32_t)),
3710+
"Assertion 'm->override_sets\\.find\\(address\\) != "
3711+
"m->override_sets\\.end\\(\\)' failed");
3712+
3713+
// Test 10: set state diff null key pointer
3714+
EXPECT_DEATH(
3715+
set_override_state_diff(
3716+
state_override,
3717+
ADDR_A.bytes,
3718+
sizeof(Address),
3719+
nullptr,
3720+
sizeof(bytes32_t),
3721+
(0x1234_bytes32).bytes,
3722+
sizeof(bytes32_t)),
3723+
"Assertion 'key' failed");
3724+
3725+
// Test 11: set state diff null value pointer
3726+
EXPECT_DEATH(
3727+
set_override_state_diff(
3728+
state_override,
3729+
ADDR_A.bytes,
3730+
sizeof(Address),
3731+
(0xABCD_bytes32).bytes,
3732+
sizeof(bytes32_t),
3733+
nullptr,
3734+
sizeof(bytes32_t)),
3735+
"Assertion 'value' failed");
3736+
3737+
// Test 12: set state diff bad key length
3738+
for (size_t len = 1; len < 1024; len *= 2) {
3739+
if (len == sizeof(bytes32_t)) {
3740+
continue;
3741+
}
3742+
uint8_t *key = new uint8_t[len];
3743+
EXPECT_DEATH(
3744+
set_override_state_diff(
3745+
state_override,
3746+
ADDR_A.bytes,
3747+
sizeof(Address),
3748+
key,
3749+
len,
3750+
(0x1234_bytes32).bytes,
3751+
sizeof(bytes32_t)),
3752+
"Assertion 'key_len == sizeof\\(bytes32_t\\)' failed");
3753+
delete[] key;
3754+
}
3755+
3756+
// Test 13: set state diff bad value length
3757+
for (size_t len = 1; len < 1024; len *= 2) {
3758+
if (len == sizeof(bytes32_t)) {
3759+
continue;
3760+
}
3761+
uint8_t *value = new uint8_t[len];
3762+
EXPECT_DEATH(
3763+
set_override_state_diff(
3764+
state_override,
3765+
ADDR_A.bytes,
3766+
sizeof(Address),
3767+
(0xABCD_bytes32).bytes,
3768+
sizeof(bytes32_t),
3769+
value,
3770+
len),
3771+
"Assertion 'value_len == sizeof\\(bytes32_t\\)' failed");
3772+
delete[] value;
3773+
}
3774+
3775+
// Test 14: set state diff overwrite existing key overwrite
3776+
set_override_state_diff(
3777+
state_override,
3778+
ADDR_A.bytes,
3779+
sizeof(Address),
3780+
(0xABCD_bytes32).bytes,
3781+
sizeof(bytes32_t),
3782+
(0x1234_bytes32).bytes,
3783+
sizeof(bytes32_t));
3784+
3785+
EXPECT_DEATH(
3786+
set_override_state_diff(
3787+
state_override,
3788+
ADDR_A.bytes,
3789+
sizeof(Address),
3790+
(0xABCD_bytes32).bytes,
3791+
sizeof(bytes32_t),
3792+
(0x5678_bytes32).bytes,
3793+
sizeof(bytes32_t)),
3794+
"state_object.find\\(k\\) == state_object.end\\(\\)");
3795+
3796+
// Test 15: set state on nonexistent address
3797+
EXPECT_DEATH(
3798+
set_override_state(
3799+
state_override,
3800+
ADDR_B.bytes,
3801+
sizeof(Address),
3802+
(0xABCD_bytes32).bytes,
3803+
sizeof(bytes32_t),
3804+
(0x1234_bytes32).bytes,
3805+
sizeof(bytes32_t)),
3806+
"Assertion 'm->override_sets\\.find\\(address\\) != "
3807+
"m->override_sets\\.end\\(\\)' failed");
3808+
3809+
// Test 16: set state null key pointer
3810+
EXPECT_DEATH(
3811+
set_override_state(
3812+
state_override,
3813+
ADDR_A.bytes,
3814+
sizeof(Address),
3815+
nullptr,
3816+
sizeof(bytes32_t),
3817+
(0x1234_bytes32).bytes,
3818+
sizeof(bytes32_t)),
3819+
"Assertion 'key' failed");
3820+
3821+
// Test 17: set state null value pointer
3822+
EXPECT_DEATH(
3823+
set_override_state(
3824+
state_override,
3825+
ADDR_A.bytes,
3826+
sizeof(Address),
3827+
(0xABCD_bytes32).bytes,
3828+
sizeof(bytes32_t),
3829+
nullptr,
3830+
sizeof(bytes32_t)),
3831+
"Assertion 'value' failed");
3832+
3833+
// Test 18: set state bad key length
3834+
for (size_t len = 1; len < 1024; len *= 2) {
3835+
if (len == sizeof(bytes32_t)) {
3836+
continue;
3837+
}
3838+
uint8_t *key = new uint8_t[len];
3839+
EXPECT_DEATH(
3840+
set_override_state(
3841+
state_override,
3842+
ADDR_A.bytes,
3843+
sizeof(Address),
3844+
key,
3845+
len,
3846+
(0x1234_bytes32).bytes,
3847+
sizeof(bytes32_t)),
3848+
"Assertion 'key_len == sizeof\\(bytes32_t\\)' failed");
3849+
delete[] key;
3850+
}
3851+
3852+
// Test 19: set state bad value length
3853+
for (size_t len = 1; len < 1024; len *= 2) {
3854+
if (len == sizeof(bytes32_t)) {
3855+
continue;
3856+
}
3857+
uint8_t *value = new uint8_t[len];
3858+
EXPECT_DEATH(
3859+
set_override_state(
3860+
state_override,
3861+
ADDR_A.bytes,
3862+
sizeof(Address),
3863+
(0xABCD_bytes32).bytes,
3864+
sizeof(bytes32_t),
3865+
value,
3866+
len),
3867+
"Assertion 'value_len == sizeof\\(bytes32_t\\)' failed");
3868+
delete[] value;
3869+
}
3870+
3871+
// Test 20: set state overwrite existing key overwrite
3872+
set_override_state(
3873+
state_override,
3874+
ADDR_A.bytes,
3875+
sizeof(Address),
3876+
(0xABCD_bytes32).bytes,
3877+
sizeof(bytes32_t),
3878+
(0x1234_bytes32).bytes,
3879+
sizeof(bytes32_t));
3880+
3881+
EXPECT_DEATH(
3882+
set_override_state(
3883+
state_override,
3884+
ADDR_A.bytes,
3885+
sizeof(Address),
3886+
(0xABCD_bytes32).bytes,
3887+
sizeof(bytes32_t),
3888+
(0x5678_bytes32).bytes,
3889+
sizeof(bytes32_t)),
3890+
"state_object.find\\(k\\) == state_object.end\\(\\)");
3891+
3892+
// Test 21: Re-add ADDR_A to the override set
3893+
EXPECT_DEATH(
3894+
add_override_address(state_override, ADDR_A.bytes, sizeof(Address)),
3895+
"Assertion 'm->override_sets\\.find\\(address\\) == "
3896+
"m->override_sets\\.end\\(\\)' failed");
3897+
3898+
monad_state_override_destroy(state_override);
3899+
}

0 commit comments

Comments
 (0)