Testing, Debugging, and Auditing Contracts BDC Practice Questions (Page 3)

Questions 11–15

1. 11foundation · easy

   Which of the following is a commonly used testing framework for Solidity smart contracts?

   • AJUnit
   • BMocha
   • CPyTest
   • DTruffle
   Reveal Solution Discussion Select an answer first
2. 12application · medium

   A team is developing a system with two contracts: `Registry` and `Token`. The `Registry` contract stores a reference to the `Token` contract and calls its `balanceOf` function. The team wants to write an integration test that verifies the `Registry` correctly interacts with the `Token` contract. Which test approach is most appropriate?

   • ADeploy only `Registry` and use a mock object to simulate the `Token` contract's `balanceOf` function.
   • BDeploy both `Registry` and `Token`, set the token address in the `Registry`, and then call `Registry` functions that use `balanceOf` to verify the returned values.
   • CWrite a test that calls the `Registry` function without setting the token address, expecting a revert.
   • DDeploy only `Token` and call its `balanceOf` function directly to verify it works.
   Reveal Solution Discussion Select an answer first
4. 13application · medium

   A developer is debugging a contract that is consuming an unexpectedly high amount of gas. The developer suspects a loop that iterates over an array. Which debugging technique would best help identify the gas consumption issue?

   • AAdd `console.log` statements inside the loop to print the loop index and see how many iterations occur.
   • BDeploy the contract to a test network and use a block explorer to view the gas used by the transaction.
   • CUse a static analysis tool to detect the loop and suggest optimizations.
   • DUse a gas reporter plugin in the testing framework to see the gas usage of each function call and identify the function with the highest gas consumption.
   Reveal Solution Discussion Select an answer first
5. 14application · medium

   A team is building a DeFi application with a `LendingPool` contract that interacts with a `PriceOracle` contract. The `LendingPool` calls `getPrice()` on the oracle to calculate collateral requirements. The team wants to write an integration test that verifies the interaction between these two contracts. Which approach is most appropriate?

   • ADeploy the real `PriceOracle` contract that fetches live market data, and then test `LendingPool` against it.
   • BDeploy only the `LendingPool` and use a local variable to simulate the oracle price, without deploying the oracle contract.
   • CWrite a unit test for `LendingPool` that mocks the oracle at the function level using a mocking library, without deploying any contract.
   • DDeploy both the `LendingPool` and a mock `PriceOracle` that returns a fixed price, then call `LendingPool` functions and verify the expected collateral calculations.
   Reveal Solution Discussion Select an answer first
6. 15application · medium

   A security audit has identified a reentrancy vulnerability in a contract's `withdraw` function. The contract currently uses `call` to send Ether to the user. Which remediation is most effective?

   • AMove the external call to a separate function that is only callable by the owner.
   • BReplace `call` with `transfer` and keep the current order of operations.
   • CAdd a reentrancy guard that uses a mutex to prevent reentrant calls, and update the user's balance before making the external call.
   • DAdd a `require` statement to check the user's balance before sending Ether.
   Reveal Solution Discussion Select an answer first