Blockchain Smart Contracts with Solidity · Aula

Fuzzing e Testes de Invariantes

Fuzzing e Testes de Invariantes é uma aula grátis de Blockchain Smart Contracts with Solidity no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Blockchain Smart Contracts with Solidity, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Limits of Example Tests

You have written unit tests with specific inputs. But attackers find the one input you did not try. Fixed examples cannot cover the huge space of possible values. This is where fuzzing helps.

What Is Fuzzing?

Fuzz testing runs a test many times with randomly generated inputs. Instead of asserting on one value, you assert a property that should hold for all inputs.

A Fuzz Test in Foundry

In Foundry, any test function parameter is automatically fuzzed. The framework feeds in many random values.

function testFuzz_DepositIncreasesBalance(uint256 amount) public {
    vm.assume(amount > 0 && amount < 1e30);
    vault.deposit(amount);
    assertEq(vault.balanceOf(address(this)), amount);
}

Bounding Inputs

Random values can be absurd (like the max uint256). Use vm.assume to discard bad inputs or bound to map a value into a valid range so tests stay meaningful.

function testFuzz_Transfer(uint256 amount) public {
    amount = bound(amount, 1, token.balanceOf(address(this)));
    token.transfer(bob, amount);
    assertEq(token.balanceOf(bob), amount);
}

Thinking in Properties

The shift is from 'with input X expect Y' to 'no matter the input, this rule holds'. Common properties:

Total supply never changes on a transfer
A user can never withdraw more than they deposited
Balances never underflow

What Are Invariants?

An invariant is a property that must hold after any sequence of operations, not just one call. Invariant testing fires many random function calls in random order, then checks the invariant after each step.

Declaring an Invariant

In Foundry, functions prefixed with invariant_ are checked after each randomized call sequence.

function invariant_TotalSupplyEqualsSumOfBalances() public {
    assertEq(token.totalSupply(), handler.sumOfBalances());
}

The Handler Pattern

Raw random calls often revert or wander into useless states. A handler contract wraps the target with guided, valid actions and tracks expected totals (ghost variables) for the invariant to check.

contract Handler {
    Token token;
    uint256 public sumOfBalances;

    function transfer(uint256 toSeed, uint256 amount) external {
        // bounded, valid transfer logic that updates ghost totals
    }
}

Shrinking Failures

When a fuzzer finds a failing input, it shrinks it to the simplest counterexample. This makes the bug far easier to understand and reproduce than a random gigantic number.

Tuning Test Runs

More runs find deeper bugs but take longer. Configure run counts in foundry.toml for CI versus quick local checks.

[fuzz]
runs = 1000

[invariant]
runs = 256
depth = 50

When to Use Each

Use fuzzing to harden individual functions against unexpected single inputs. Use invariant testing to verify system-wide rules survive any sequence of actions. Together they catch classes of bugs fixed tests never reach.

Quick Check

Test your understanding of property-based testing.

Recap

You learned fuzzing and invariant testing:

Fuzzing runs functions with many random inputs against properties
vm.assume and bound keep inputs valid
Invariants check system rules across random call sequences
Handlers guide actions; shrinking simplifies failures

These techniques uncover edge cases that example-based tests miss.

Perguntas Frequentes

A aula “Fuzzing e Testes de Invariantes” é grátis?

Sim — o texto completo de “Fuzzing e Testes de Invariantes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Blockchain Smart Contracts with Solidity, atualize para CoddyKit PRO. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

O que vou aprender em “Fuzzing e Testes de Invariantes”?

Aprenda como fuzzing baseado em propriedades e testes de invariantes detectam erros de casos extremos em contratos inteligentes que testes unitários fixos não encontram, usando Foundry como estrutura… Você pratica Blockchain Smart Contracts with Solidity com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Blockchain Smart Contracts with Solidity?

Nenhuma experiência prévia é necessária. Blockchain Smart Contracts with Solidity no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Fuzzing e Testes de Invariantes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Blockchain Smart Contracts with Solidity?

Sim. Cada aula de Blockchain Smart Contracts with Solidity inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Blockchain Smart Contracts with Solidity