Assertion patterns in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an assertion in software testing?

An assertion is a statement that checks if a condition is true during a test. If the condition is false, the test fails. It helps verify that the code works as expected.

intermediate

Why are assertion patterns important in blockchain testing?

Assertion patterns help ensure blockchain code behaves correctly, such as verifying transactions, smart contract states, and security rules. They catch errors early and improve trust in the system.

beginner

Name a common assertion pattern used in blockchain smart contract tests.

One common pattern is asserting that a transaction emits the expected event. This confirms that the contract executed the correct action.

intermediate

How does the 'assert revert' pattern work in blockchain testing?

It checks that a transaction fails and reverts when given bad input or unauthorized access. This ensures the contract protects against invalid actions.

advanced

What is the benefit of using multiple assertion patterns in one blockchain test?

Using multiple assertions checks different parts of the code and outcomes. This gives a fuller picture of correctness and helps find bugs faster.

What does an assertion do in a blockchain test?

A Generates blockchain addresses

B Runs the blockchain node

C Deploys the smart contract

D Checks if a condition is true and fails the test if not

Assertions verify conditions during tests and cause failures if conditions are false.

Which assertion pattern verifies that a smart contract emitted an event?

A Assert revert

B Assert balance change

C Assert event emission

D Assert transaction hash

Assert event emission checks that the contract emitted the expected event during execution.

What does the 'assert revert' pattern test for?

A Transaction failure and rollback

B Block confirmation time

C Correct gas usage

D Successful transaction completion

'Assert revert' ensures that invalid transactions fail and the blockchain state does not change.

Why use multiple assertions in one blockchain test?

A To check different outcomes and improve test coverage

B To slow down the test

C To confuse developers

D To reduce gas fees

Multiple assertions verify various aspects of the code, catching more bugs and improving confidence.

Which of these is NOT a typical assertion in blockchain testing?

A Assert event emitted

B Assert UI color scheme

C Assert transaction success

D Assert revert on error

UI color scheme is unrelated to blockchain logic testing and assertions.

Explain how assertion patterns help improve blockchain smart contract testing.

Think about how assertions check conditions and outcomes in tests.

Describe the 'assert revert' pattern and why it is important in blockchain testing.

Consider what happens when a smart contract should reject a bad input.

Practice

1.

What is the main purpose of an assertion in blockchain smart contract testing?

easy

A. To optimize the contract's gas usage

B. To log information without affecting execution

C. To deploy the contract to the blockchain

D. To check if a condition is true and stop execution if false

Solution

1. Step 1: Understand assertion role

   Assertions verify conditions during execution to ensure correctness.

2. Step 2: Identify assertion effect

   If the condition is false, assertions stop execution and revert changes to prevent errors.

3. Final Answer:

   To check if a condition is true and stop execution if false -> Option D

4. Quick Check:

   Assertions stop execution on false condition [OK]

Hint: Assertions stop code if condition fails, preventing errors [OK]

Common Mistakes:

• Thinking assertions only log info without stopping
• Confusing assertions with deployment steps
• Assuming assertions optimize gas usage

2.

Which of the following is the correct syntax for an assertion in Solidity?

?

easy

A. assert: balance >= amount;

B. assert(balance >= amount);

C. assert(balance < amount);

D. assert(balance = amount);

Solution

1. Step 1: Recall Solidity assertion syntax

   Assertions use the function-like syntax: assert(condition);

2. Step 2: Check condition correctness

   Condition should be a boolean expression, here balance >= amount is valid.

3. Final Answer:

   assert(balance >= amount); -> Option B

4. Quick Check:

   assert(condition) uses parentheses and semicolon [OK]

Hint: Assertions use assert(condition); with parentheses and semicolon [OK]

Common Mistakes:

• Using colon instead of parentheses
• Using assignment (=) instead of comparison (>=)
• Writing incorrect comparison operators

3.

Consider this Solidity code snippet:

uint balance = 100;
uint amount = 150;
assert(balance >= amount);

What will happen when this code runs?

medium

A. Execution continues normally

B. balance is updated to amount

C. Execution stops and reverts due to failed assertion

D. Compilation error due to invalid assertion

Solution

1. Step 1: Evaluate assertion condition

   balance is 100, amount is 150, so balance >= amount is false.

2. Step 2: Understand assertion behavior on false

   Assertion fails, so execution stops and reverts all changes.

3. Final Answer:

   Execution stops and reverts due to failed assertion -> Option C

4. Quick Check:

   False assertion stops execution [OK]

Hint: False assertion stops execution and reverts changes [OK]

Common Mistakes:

• Assuming code continues after failed assertion
• Thinking assertion causes compile error
• Believing balance changes automatically

4.

Identify the error in this Solidity assertion statement:

assert(balance = amount);

medium

A. Using assignment operator instead of comparison

B. Missing semicolon at the end

C. Incorrect function name, should be require()

D. balance and amount are undefined

Solution

1. Step 1: Analyze operator usage

   The single equals sign (=) assigns value, not compares values.

2. Step 2: Correct operator for assertion

   Assertions require comparison operators like == or >= to check conditions.

3. Final Answer:

   Using assignment operator instead of comparison -> Option A

4. Quick Check:

   Use '==' for comparison in assertions [OK]

Hint: Use '==' for comparison, not '=' assignment in assertions [OK]

Common Mistakes:

• Confusing '=' with '==' in conditions
• Thinking require() must replace assert() always
• Ignoring missing semicolon (which is present here)

5.

You want to assert that a user's balance is positive and provide a clear error message if not. Which assertion pattern is best?

?

hard

A. require(balance > 0, "Balance must be positive");

B. assert(balance > 0, "Balance must be positive");

C. assert(balance > 0);

D. if(balance <= 0) revert("Balance must be positive");

Solution

1. Step 1: Understand assertion vs require

   In Solidity, assert is for internal errors without messages; require allows error messages.

2. Step 2: Choose assertion with message

   require(condition, message) is best to check user input and show clear error.

3. Final Answer:

   require(balance > 0, "Balance must be positive"); -> Option A

4. Quick Check:

   Use require() for checks with error messages [OK]

Hint: Use require() to assert with clear error messages [OK]

Common Mistakes:

• Using assert() with message (not supported)
• Ignoring error messages in assertions
• Using if + revert instead of require() unnecessarily