repo_id stringclasses 409
values | prefix large_stringlengths 34 36.3k | target large_stringlengths 1 498 | assertion_type stringclasses 31
values | difficulty stringclasses 8
values | test_file stringlengths 10 121 | test_function stringlengths 1 104 | test_class stringlengths 0 51 | lineno int32 2 11.3k | commit_idx int32 |
|---|---|---|---|---|---|---|---|---|---|
curvefi/curve-dao-contracts | import brownie
MAX_UINT256 = 2 ** 256 - 1
WEEK = 7 * 86400
def test_kick(chain, accounts, liquidity_gauge, voting_escrow, token, mock_lp_token):
alice, bob = accounts[:2]
chain.sleep(2 * WEEK + 5)
token.approve(voting_escrow, MAX_UINT256, {"from": alice})
voting_escrow.create_lock(10 ** 20, chain.tim... | 10 ** 21 | assert | complex_expr | tests/unitary/LiquidityGauge/test_kick.py | test_kick | 17 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
DAY = 86400
def local_setup(alice, charlie, coin_reward, child_chain_streamer):
coin_reward._mint_for_testing(alice, 100 * 10 ** 18)
coin_reward.transfer(child_chain_streamer, 100 * 10 ** 18, {"from": alice})
def test_reward_data_cleared(alice, ch... | (ZERO_ADDRESS, 0, 0, 0, 0, 0) | assert | collection | tests/unitary/Sidechain/child_chain_streamer/test_remove_reward.py | test_reward_data_cleared | 33 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import Contract
def burner(ABurner, alice, receiver):
yield ABurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in ctokens], ids=[i[1] for i in ctokens])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.mark.pa... | 0 | assert | numeric_literal | tests/fork/Burners/test_aburner.py | test_ctoken_unwrap | 37 | null | |
curvefi/curve-dao-contracts | from random import random, randrange
from tests.conftest import YEAR, approx
MAX_UINT256 = 2 ** 256 - 1
WEEK = 7 * 86400
def test_mining_with_votelock(
accounts,
chain,
history,
mock_lp_token,
token,
gauge_v3,
gauge_controller,
voting_escrow,
):
alice, bob = accounts[:2]
chain... | 0 | assert | numeric_literal | tests/integration/LiquidityGaugeV3/test_liquidity_gauge_v3.py | test_mining_with_votelock | 152 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ETH_ADDRESS, ZERO_ADDRESS, Contract
def receiver(UnderlyingBurner, alice, receiver):
yield UnderlyingBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
def burner(SynthBurner, alice, receiver):
contract = SynthBurner.deploy(receiver, receiver, alice, alice, {"fr... | 2 | assert | numeric_literal | tests/fork/Burners/test_synth_burner.py | test_swap | 72 | null | |
curvefi/curve-dao-contracts | import pytest
YEAR = 86400 * 365
def gauge_vote_setup(accounts, chain, gauge_controller, three_gauges, voting_escrow, token):
gauge_controller.add_type(b"Insurance", {"from": accounts[0]})
gauge_controller.add_gauge(three_gauges[0], 0, {"from": accounts[0]})
gauge_controller.add_gauge(three_gauges[1], 1, ... | 10 ** 18 | assert | complex_expr | tests/unitary/GaugeController/test_vote_weight_unitary.py | test_effect_on_following_period | 26 | null | |
curvefi/curve-dao-contracts | from brownie import (
ZERO_ADDRESS,
ABurner,
BTCBurner,
CBurner,
Contract,
ETHBurner,
EuroBurner,
FeeDistributor,
LPBurner,
MetaBurner,
PoolProxy,
UnderlyingBurner,
USDNBurner,
YBurner,
accounts,
chain,
history,
)
BURNERS = {
LPBurner: ["0x075b1bb... | 2 | assert | numeric_literal | tests/fork/Burners/test_fee_distribution.py | test_fee_distribution | 183 | null | |
curvefi/curve-dao-contracts | import pytest
amounts = [10 ** 17 * i for i in range(1, 101)]
def initial_funding(vesting, accounts):
vesting.add_tokens(10 ** 21, {"from": accounts[0]})
vesting.fund(accounts[:100], amounts, {"from": accounts[0]})
def test_vested_supply(chain, vesting, end_time):
assert vesting.vestedSupply() == 0
c... | sum(amounts) | assert | func_call | tests/unitary/VestingEscrow/test_getters.py | test_vested_supply | 16 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract(RewardStream, alice, charlie, rewards_only_gauge, coin_reward):
contract = RewardStream.deploy(alice, charlie, coin_reward, 86400 * 7, {"from": alice})
... | tuple(rewards) | assert | func_call | tests/unitary/RewardsOnlyGauge/test_claim_rewards_unipool.py | test_claim_two_lp | 110 | null | |
curvefi/curve-dao-contracts | import brownie
def test_set_approve_deposit_true(accounts, gauge_v2):
gauge_v2.set_approve_deposit(accounts[0], True, {"from": accounts[1]})
assert gauge_v2.approved_to_deposit(accounts[0], accounts[1]) is | True | assert | bool_literal | tests/unitary/LiquidityGaugeV2/test_deposit_for.py | test_set_approve_deposit_true | 22 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
AMOUNTS = [10 ** 17 * i for i in range(1, 101)]
def initial_setup(accounts, vesting):
vesting.add_tokens(10 ** 21, {"from": accounts[0]})
def test_event(vesting, accounts):
tx = vesting.fund(accounts[:100], AMOUNTS, {"fr... | [acct, expected_amount] | assert | collection | tests/unitary/VestingEscrow/test_fund.py | test_event | 41 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ETH_ADDRESS, Contract
from brownie_tokens import MintableForkToken, skip_holders
WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
swap_datas = [
{
"_from": "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6",
"_to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE36... | 0 | assert | numeric_literal | tests/fork/Burners/test_swap_crypto_burner.py | test_burn | 116 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie.test import given, strategy
from hypothesis import settings
def initial_setup(accounts, reward_contract, mock_lp_token, liquidity_gauge_reward):
mock_lp_token.approve(liquidity_gauge_reward, 2 ** 256 - 1, {"from": accounts[0]})
liquidity_gauge_reward.deposit(100000, {"from": accounts... | 10 ** 18 | assert | complex_expr | tests/integration/LiquidityGaugeReward/test_borked_rewards.py | test_withdraw_borked_rewards | 40 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def initial_setup(
alice,
bob,
chain,
coin_reward,
reward_contract,
token,
mock_lp_token,
gauge_v3,
gauge_controller,
minter,
):
# gauge... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV3/test_claim_rewards_unipool.py | test_claim_one_lp | 56 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def test_set_admins(accounts, pool_proxy):
pool_proxy.commit_set_admins(accounts[1], accounts[2], accounts[3], {"from": accounts[0]})
pool_proxy.apply_set_admins()
assert pool_proxy.ownership_admin() == accounts[1]
... | accounts[3] | assert | complex_expr | tests/unitary/PoolProxy/test_set_admins.py | test_set_admins | 13 | null | |
curvefi/curve-dao-contracts | import brownie
WEEK = 7 * 86400
YEAR = 365 * 86400
TYPE_WEIGHTS = [5 * 10 ** 17, 2 * 10 ** 18]
GAUGE_WEIGHTS = [2 * 10 ** 18, 10 ** 18, 5 * 10 ** 17]
def test_n_gauges(accounts, gauge_controller, three_gauges):
assert gauge_controller.n_gauges() == | 0 | assert | numeric_literal | tests/unitary/GaugeController/test_gauges_weights.py | test_n_gauges | 19 | null | |
curvefi/curve-dao-contracts | import pytest
def test_approve(rewards_only_gauge, accounts):
rewards_only_gauge.approve(accounts[1], 10 ** 19, {"from": accounts[0]})
assert rewards_only_gauge.allowance(accounts[0], accounts[1]) == | 10 ** 19 | assert | complex_expr | tests/unitary/RewardsOnlyGauge/test_approve.py | test_approve | 12 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract_2(CurveRewards, mock_lp_token, accounts, coin_a):
contract = CurveRewards.deploy(mock_lp_token, coin_a, {"from": accounts[0]})
contract.setRewardDistrib... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV2/test_claim_historic_rewards.py | test_unset_and_claim_historic | 42 | null | |
curvefi/curve-dao-contracts | import brownie
from brownie import chain
from brownie.test import strategy
from tests.conftest import approx
class StateMachine:
st_account = strategy("address", length=5)
st_value = strategy("uint64", min_value=10 ** 10)
st_time = strategy("uint", max_value=365 * 86400)
st_reward = strategy("uint64"... | balance | assert | variable | tests/integration/LiquidityGaugeReward/test_rewards_total.py | invariant_balances | StateMachine | 103 | null |
curvefi/curve-dao-contracts | import pytest
@pytest.mark.parametrize("idx", range(5))
def test_initial_approval_is_zero(reward_gauge_wrapper, accounts, idx):
assert reward_gauge_wrapper.allowance(accounts[0], accounts[idx]) == | 0 | assert | numeric_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_approve.py | test_initial_approval_is_zero | 8 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def test_immediate_change_of_admin(alice, bob, root_gauge):
root_gauge.set_checkpoint_admin(bob, {"from": alice})
assert root_gauge.checkpoint_admin() == | bob | assert | variable | tests/unitary/Sidechain/test_set_checkpoint_admin.py | test_immediate_change_of_admin | 14 | null | |
curvefi/curve-dao-contracts | import pytest
def test_approve(unit_gauge, accounts):
unit_gauge.approve(accounts[1], 10 ** 19, {"from": accounts[0]})
assert unit_gauge.allowance(accounts[0], accounts[1]) == | 10 ** 19 | assert | complex_expr | tests/unitary/LiquidityGaugeWrapperUnit/test_approve.py | test_approve | 14 | null | |
curvefi/curve-dao-contracts | import brownie
def test_reward_data_updated(alice, charlie, child_chain_streamer, token):
child_chain_streamer.add_reward(token, charlie, 86400 * 7, {"from": alice})
expected_data = (charlie, 0, 0, 86400 * 7, 0, 0)
assert child_chain_streamer.reward_count() == 2
assert child_chain_streamer.reward_to... | token | assert | variable | tests/unitary/Sidechain/child_chain_streamer/test_add_reward.py | test_reward_data_updated | 15 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS, Contract
from brownie_tokens import MintableForkToken
LP_TOKENS = [
"0x4DEcE678ceceb27446b35C672dC7d61F30bAD69E", # USDC/crvUSD
"0x34d655069f4cac1547e4c8ca284ffff5ad4a8db0", # TUSD/crvUSD
"0x390f3595bca2df7d23783dfd126427cceb997bf4", # USDT/crvUSD
"0xc... | 0 | assert | numeric_literal | tests/fork/Burners/test_crvburner.py | test_lp | 85 | null | |
curvefi/curve-dao-contracts | import brownie
def test_set_approve_deposit_true(accounts, liquidity_gauge_reward):
liquidity_gauge_reward.set_approve_deposit(accounts[0], True, {"from": accounts[1]})
assert liquidity_gauge_reward.approved_to_deposit(accounts[0], accounts[1]) is | True | assert | bool_literal | tests/unitary/LiquidityGaugeReward/test_deposit_for_rewards.py | test_set_approve_deposit_true | 22 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
DAY = 86400
owner_functions_mock = """
# @version 0.2.7
aave: public(uint256)
donated: public(bool)
withdrawn: public(uint256)
@payable
@external
def __default__():
pass
@external
def set_aave_referral(referral_code: uint2... | accounts[4] | assert | complex_expr | tests/unitary/CryptoPoolProxy/test_owner_admin_crypto.py | test_transfer_ownership | 46 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
DAY = 86400
def param_pool(accounts):
pool_parameters_mock = """
# @version 0.2.12
A_MULTIPLIER: constant(uint256) = 100
ADMIN_ACTIONS_DELAY: constant(uint256) = 3 * 86400
MIN_RAMP_TIME: constant(uint256) = 86400
MAX_ADMIN_F... | 0 | assert | numeric_literal | tests/unitary/CryptoPoolProxy/test_parameter_admin_crypto.py | test_revert_new_parameters | 377 | null | |
curvefi/curve-dao-contracts | import pytest
WEEK = 86400 * 7
def distributor(accounts, chain, fee_distributor, voting_escrow, token):
distributor = fee_distributor()
token.approve(voting_escrow, 2 ** 256 - 1, {"from": accounts[0]})
voting_escrow.create_lock(10 ** 21, chain.time() + WEEK * 52, {"from": accounts[0]})
yield distrib... | 0 | assert | numeric_literal | tests/unitary/FeeDistribution/test_checkpoints.py | test_checkpoint_total_supply | 27 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
AMOUNTS = [10 ** 17 * i for i in range(1, 101)]
def initial_setup(accounts, vesting):
vesting.add_tokens(10 ** 21, {"from": accounts[0]})
def test_balanceOf(coin_a, vesting):
assert coin_a.balanceOf(vesting) == | 10 ** 21 | assert | complex_expr | tests/unitary/VestingEscrow/test_fund.py | test_balanceOf | 14 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(accounts, gauge_controller, minter, gauge_v2, token, mock_lp_token):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_controller.add_gauge(gauge_v2, 0, 0, {"from": accounts[0]})
mock_l... | [accounts[0], accounts[2], amount] | assert | collection | tests/unitary/LiquidityGaugeV2/test_transferFrom.py | test_transfer_event_fires | 182 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | True | assert | bool_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_transfer.py | test_returns_true | 56 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
def test_assumptions(gauge_proxy, alice, bob):
assert gauge_proxy.ownership_admin() == | alice | assert | variable | tests/unitary/GaugeProxy/test_gauge_proxy_set_admins.py | test_assumptions | 7 | null | |
curvefi/curve-dao-contracts | import brownie
WEEK = 7 * 86400
YEAR = 365 * 86400
TYPE_WEIGHTS = [5 * 10 ** 17, 2 * 10 ** 18]
GAUGE_WEIGHTS = [2 * 10 ** 18, 10 ** 18, 5 * 10 ** 17]
def test_gauge_weight(accounts, gauge_controller, gauge):
gauge_controller.add_gauge(gauge, 0, 10 ** 19, {"from": accounts[0]})
assert gauge_controller.get_g... | 10 ** 19 | assert | complex_expr | tests/unitary/GaugeController/test_gauges_weights.py | test_gauge_weight | 57 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def initial_setup(
alice,
bob,
chain,
coin_reward,
reward_contract,
token,
mock_lp_token,
gauge_v2,
gauge_controller,
minter,
):
# gauge... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV2/test_claim_rewards_unipool.py | test_claim_one_lp | 56 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract_2(CurveRewards, mock_lp_token, accounts, coin_a):
contract = CurveRewards.deploy(mock_lp_token, coin_a, {"from": accounts[0]})
contract.s... | [ZERO_ADDRESS] * 8 | assert | collection | tests/unitary/LiquidityGaugeV2/test_set_rewards_deposit.py | test_unset_no_totalsupply | 40 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | 0 | assert | numeric_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_transfer.py | test_transfer_full_balance | 65 | null | |
curvefi/curve-dao-contracts | def test_vested_supply(chain, vesting_simple, end_time):
assert vesting_simple.vestedSupply() == 0
chain.sleep(end_time - chain.time())
chain.mine()
assert vesting_simple.vestedSupply() == | 10 ** 20 | assert | complex_expr | tests/unitary/VestingEscrowFactory/test_getters_simple.py | test_vested_supply | 5 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | [accounts[0], accounts[1], amount] | assert | collection | tests/unitary/LiquidityGaugeRewardWrapper/test_transfer.py | test_transfer_event_fires | 99 | null | |
curvefi/curve-dao-contracts | import brownie
MAX_UINT256 = 2 ** 256 - 1
WEEK = 7 * 86400
def test_kick(chain, accounts, gauge_v3, voting_escrow, token, mock_lp_token):
alice, bob = accounts[:2]
chain.sleep(2 * WEEK + 5)
token.approve(voting_escrow, MAX_UINT256, {"from": alice})
voting_escrow.create_lock(10 ** 20, chain.time() + 4... | 10 ** 21 | assert | complex_expr | tests/unitary/LiquidityGaugeV3/test_kick.py | test_kick | 17 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def test_set_admins(accounts, pool_proxy):
pool_proxy.commit_set_admins(accounts[1], accounts[2], accounts[3], {"from": accounts[0]})
pool_proxy.apply_set_admins()
assert pool_proxy.ownership_admin() == | accounts[1] | assert | complex_expr | tests/unitary/PoolProxy/test_set_admins.py | test_set_admins | 11 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import Contract
def burner(CBurner, alice, receiver):
yield CBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in ctokens], ids=[i[1] for i in ctokens])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.mark.pa... | 0 | assert | numeric_literal | tests/fork/Burners/test_cburner.py | test_ctoken_unwrap | 36 | null | |
curvefi/curve-dao-contracts | import pytest
def burner(UnderlyingBurner, alice, receiver):
yield UnderlyingBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in tripool], ids=[i[1] for i in tripool])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.mark.parametrize("... | amount | assert | variable | tests/fork/Burners/test_underlying_burner.py | test_burn_no_swap | 42 | null | |
curvefi/curve-dao-contracts | import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def initial_funding(vesting, accounts):
recipients = [accounts[1]] + [ZERO_ADDRESS] * 99
vesting.add_tokens(10 ** 21, {"from": accounts[0]})
vesting.fund(recipients, [10 ** 20] + [0] * 99, {"from": accounts[0]})
def test_disable_af... | 10 ** 20 | assert | complex_expr | tests/unitary/VestingEscrow/test_disable_and_claim.py | test_disable_after_end_time | 18 | null | |
curvefi/curve-dao-contracts | import brownie
def test_commit_transfer_ownership(vesting, accounts):
vesting.commit_transfer_ownership(accounts[1], {"from": accounts[0]})
assert vesting.admin() == accounts[0]
assert vesting.future_admin() == | accounts[1] | assert | complex_expr | tests/unitary/VestingEscrow/test_vesting_escrow_admin.py | test_commit_transfer_ownership | 18 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def test_set_admins(accounts, pool_proxy):
pool_proxy.commit_set_admins(accounts[1], accounts[2], accounts[3], {"from": accounts[0]})
pool_proxy.apply_set_admins()
assert pool_proxy.ownership_admin() == accounts[1]
... | accounts[2] | assert | complex_expr | tests/unitary/PoolProxy/test_set_admins.py | test_set_admins | 12 | null | |
curvefi/curve-dao-contracts | import brownie
def test_set_approve_deposit_toggle(accounts, gauge_v2):
for value in [True, True, False, False, True, False, True]:
gauge_v2.set_approve_deposit(accounts[0], value, {"from": accounts[1]})
assert gauge_v2.approved_to_deposit(accounts[0], accounts[1]) is | value | assert | variable | tests/unitary/LiquidityGaugeV2/test_deposit_for.py | test_set_approve_deposit_toggle | 33 | null | |
curvefi/curve-dao-contracts | import brownie
def test_commit_transfer_ownership(gauge_controller, accounts):
gauge_controller.commit_transfer_ownership(accounts[1], {"from": accounts[0]})
assert gauge_controller.admin() == accounts[0]
assert gauge_controller.future_admin() == | accounts[1] | assert | complex_expr | tests/unitary/GaugeController/test_gaugecontroller_admin.py | test_commit_transfer_ownership | 18 | null | |
curvefi/curve-dao-contracts | from random import random, randrange
from tests.conftest import YEAR, approx
MAX_UINT256 = 2 ** 256 - 1
WEEK = 7 * 86400
def test_mining_with_votelock(
accounts,
chain,
history,
mock_lp_token,
token,
gauge_v3,
gauge_controller,
voting_escrow,
):
alice, bob = accounts[:2]
chain... | d_bob | assert | variable | tests/integration/LiquidityGaugeV3/test_liquidity_gauge_v3.py | test_mining_with_votelock | 179 | null | |
curvefi/curve-dao-contracts | import pytest
def test_returns_true(gauge_v2, accounts):
tx = gauge_v2.approve(accounts[1], 10 ** 19, {"from": accounts[0]})
assert tx.return_value is | True | assert | bool_literal | tests/unitary/LiquidityGaugeV2/test_approve.py | test_returns_true | 44 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS, compile_source
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
code = """
# @version 0.2.7
from vyper.interfaces import ERC20
first: address
second: address
@external
def __init__(_first: address, _second: address):
self... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV2/test_claim_rewards_multiple.py | test_claim_for_other | 81 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
def test_assumptions(gauge_proxy, alice, bob):
assert gauge_proxy.ownership_admin() == alice
assert gauge_proxy.emergency_admin() == | bob | assert | variable | tests/unitary/GaugeProxy/test_gauge_proxy_set_admins.py | test_assumptions | 8 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract_2(CurveRewards, mock_lp_token, accounts, coin_a):
contract = CurveRewards.deploy(mock_lp_token, coin_a, {"from": accounts[0]})
contract.s... | [coin_reward] + [ZERO_ADDRESS] * 7 | assert | collection | tests/unitary/LiquidityGaugeV3/test_set_rewards_deposit.py | test_unset_no_totalsupply | 40 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
DAY = 86400
owner_functions_mock = """
# @version 0.2.7
aave: public(uint256)
donated: public(bool)
withdrawn: public(uint256)
@payable
@external
def __default__():
pass
@external
def set_aave_referral(referral_code: uint2... | 0 | assert | numeric_literal | tests/unitary/CryptoPoolProxy/test_owner_admin_crypto.py | test_unset_burner | 154 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
AMOUNTS = [10 ** 17 * i for i in range(1, 101)]
def initial_setup(accounts, vesting):
vesting.add_tokens(10 ** 21, {"from": accounts[0]})
def test_initial_locked_supply(vesting, accounts):
vesting.fund(accounts[:100], AM... | sum(AMOUNTS) | assert | func_call | tests/unitary/VestingEscrow/test_fund.py | test_initial_locked_supply | 20 | null | |
curvefi/curve-dao-contracts | import brownie
WEEK = 7 * 86400
YEAR = 365 * 86400
TYPE_WEIGHTS = [5 * 10 ** 17, 2 * 10 ** 18]
GAUGE_WEIGHTS = [2 * 10 ** 18, 10 ** 18, 5 * 10 ** 17]
def test_n_gauges(accounts, gauge_controller, three_gauges):
assert gauge_controller.n_gauges() == 0
gauge_controller.add_gauge(three_gauges[0], 0, {"from": a... | 2 | assert | numeric_literal | tests/unitary/GaugeController/test_gauges_weights.py | test_n_gauges | 24 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def initial_setup(
alice,
bob,
chain,
coin_reward,
reward_contract,
token,
mock_lp_token,
gauge_v2,
gauge_controller,
minter,
):
# gauge... | tuple(rewards) | assert | func_call | tests/unitary/LiquidityGaugeV2/test_claim_rewards_unipool.py | test_claim_two_lp | 102 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def test_set_admins(accounts, crypto_pool_proxy):
crypto_pool_proxy.commit_set_admins(
accounts[1], accounts[2], accounts[3], {"from": accounts[0]}
)
crypto_pool_proxy.apply_set_admins()
assert crypto_poo... | accounts[2] | assert | complex_expr | tests/unitary/CryptoPoolProxy/test_set_admins_crypto.py | test_set_admins | 14 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def initial_setup(
alice,
bob,
chain,
coin_reward,
reward_contract,
token,
mock_lp_token,
gauge_v3,
gauge_controller,
minter,
):
# gauge... | tuple(rewards) | assert | func_call | tests/unitary/LiquidityGaugeV3/test_claim_rewards_unipool.py | test_claim_two_lp | 103 | null | |
curvefi/curve-dao-contracts | import brownie
def test_set_approve_deposit_true(accounts, liquidity_gauge):
liquidity_gauge.set_approve_deposit(accounts[0], True, {"from": accounts[1]})
assert liquidity_gauge.approved_to_deposit(accounts[0], accounts[1]) is | True | assert | bool_literal | tests/unitary/LiquidityGauge/test_deposit_for.py | test_set_approve_deposit_true | 22 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def param_pool(accounts):
pool_parameters_mock = """
amp: public(uint256)
fee: public(uint256)
admin_fee: public(uint256)
future_amp: public(uint256)
future_fee: public(uint256)
future_admin_fee: public(uint256)
@external
... | time | assert | variable | tests/unitary/PoolProxy/test_parameter_admin.py | test_ramp_A | 104 | null | |
curvefi/curve-dao-contracts | import itertools
import pytest
TYPE_WEIGHTS = [5e17, 1e19]
GAUGE_WEIGHTS = [1e19, 1e18, 5e17]
GAUGE_TYPES = [0, 0, 1]
MONTH = 86400 * 30
WEEK = 7 * 86400
def setup(accounts, mock_lp_token, token, minter, gauge_controller, liquidity_gauge, unit_gauge):
token.set_minter(minter, {"from": accounts[0]})
gauge_c... | balance | assert | variable | tests/unitary/LiquidityGaugeWrapperUnit/test_claim_tokens.py | test_multiple_claims | 72 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def local_setup(alice, bob, root_gauge):
root_gauge.commit_transfer_ownership(bob, {"from": alice})
def test_event_emitted(bob, root_gauge):
tx = root_gauge.accept_transfer_ownership({"from": bob})
assert "ApplyOwnership" in | tx.events | assert | complex_expr | tests/unitary/Sidechain/test_accept_transfer_ownership.py | test_event_emitted | 27 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie.test import given, strategy
from tests.conftest import INITIAL_SUPPLY, YEAR, YEAR_1_SUPPLY, approx
def initial_setup(chain, token):
chain.sleep(86401)
token.update_mining_parameters()
@given(time=strategy("decimal", min_value=1, max_value=7))
def test_mintable_in_timeframe(accounts... | 0 | assert | numeric_literal | tests/integration/ERC20CRV/test_mintable_in_timeframe.py | test_mintable_in_timeframe | 29 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def deposit_setup(accounts, liquidity_gauge, mock_lp_token):
mock_lp_token.approve(liquidity_gauge, 2 ** 256 - 1, {"from": accounts[0]})
def test_deposit_zero(accounts, liquidity_gauge, mock_lp_token):
balance = mock_lp_token.balanceOf(accounts[0])
liquidity_gauge.deposit(0, {... | 0 | assert | numeric_literal | tests/unitary/LiquidityGauge/test_deposit_withdraw.py | test_deposit_zero | 24 | null | |
curvefi/curve-dao-contracts | import brownie
from brownie import chain
from brownie.test import strategy
class StateMachine:
st_account = strategy("address", length=5)
st_value = strategy("uint64")
st_time = strategy("uint", max_value=86400 * 365)
def __init__(self, accounts, liquidity_gauge, mock_lp_token):
self.accounts... | balance | assert | variable | tests/integration/LiquidityGauge/test_deposits_withdrawals.py | invariant_balances | StateMachine | 80 | null |
curvefi/curve-dao-contracts | import pytest
def test_approval_event_fires(accounts, reward_gauge_wrapper):
tx = reward_gauge_wrapper.approve(accounts[1], 10 ** 19, {"from": accounts[0]})
assert len(tx.events) == | 1 | assert | numeric_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_approve.py | test_approval_event_fires | 52 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
owner_functions_mock = """
# @version 0.2.7
aave: public(uint256)
donated: public(bool)
withdrawn: public(uint256)
@payable
@external
def __default__():
pass
@external
def set_aave_referral(referral_code: uint256):
sel... | accounts[4] | assert | complex_expr | tests/unitary/PoolProxy/test_owner_admin.py | test_transfer_ownership | 44 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | True | assert | bool_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_transferFrom.py | test_returns_true | 98 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
def initial_funding(coin_a, vesting_factory):
coin_a._mint_for_testing(vesting_factory, 10 ** 21)
def test_token_xfer(vesting_simple, coin_a):
# exactly 10**18 tokens should be transferred
assert coin_a.balanceOf(vesting_simple) == | 10 ** 20 | assert | complex_expr | tests/unitary/VestingEscrowFactory/test_deploy_escrow.py | test_token_xfer | 75 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import Contract
def burner(YBurner, alice, receiver):
yield YBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in y_unwrap], ids=[i[1] for i in y_unwrap])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.mark.... | 0 | assert | numeric_literal | tests/fork/Burners/test_yburner.py | test_unwrap | 45 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def deposit_setup(accounts, gauge_v3, mock_lp_token):
mock_lp_token.approve(gauge_v3, 2 ** 256 - 1, {"from": accounts[0]})
def test_deposit_zero(accounts, gauge_v3, mock_lp_token):
balance = mock_lp_token.balanceOf(accounts[0])
gauge_v3.deposit(0, {"from": accounts[0]})
a... | balance | assert | variable | tests/unitary/LiquidityGaugeV3/test_deposit_withdraw.py | test_deposit_zero | 25 | null | |
curvefi/curve-dao-contracts | import brownie
def test_recover_balance(burner, alice, receiver, coin_a):
coin_a._mint_for_testing(burner, 10 ** 18)
burner.recover_balance(coin_a, {"from": alice})
assert coin_a.balanceOf(burner) == 0
assert coin_a.balanceOf(receiver) == | 10 ** 18 | assert | complex_expr | tests/unitary/Burners/test_recover_tokens.py | test_recover_balance | 10 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS, compile_source
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
code = """
# @version 0.2.7
from vyper.interfaces import ERC20
first: address
second: address
@external
def __init__(_first: address, _second: address):
self... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV3/test_set_rewards_receiver.py | test_claim_one_lp | 71 | null | |
curvefi/curve-dao-contracts | import brownie
def test_set_reward_duration_admin_only(alice, bob, token, child_chain_streamer):
with brownie.reverts("dev: only owner"):
child_chain_streamer.set_reward_duration(token, 86400 * 7, {"from": bob})
child_chain_streamer.set_reward_duration(token, 86400 * 7, {"from": alice})
assert c... | 86400 * 7 | assert | complex_expr | tests/unitary/Sidechain/child_chain_streamer/test_admin_functions.py | test_set_reward_duration_admin_only | 10 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
DAY = 86400
owner_functions_mock = """
# @version 0.2.7
aave: public(uint256)
donated: public(bool)
withdrawn: public(uint256)
@payable
@external
def __default__():
pass
@external
def set_aave_referral(referral_code: uint2... | 1 | assert | numeric_literal | tests/unitary/CryptoPoolProxy/test_owner_admin_crypto.py | test_withdraw_admin_fees | 119 | null | |
curvefi/curve-dao-contracts | import itertools
import pytest
MONTH = 86400 * 30
WEEK = 86400 * 7
def setup(
accounts,
mock_lp_token,
token,
minter,
gauge_controller,
liquidity_gauge_reward,
reward_gauge_wrapper,
reward_contract,
coin_reward,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_con... | 0 | assert | numeric_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_claim_tokens.py | test_claim_crv | 48 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def local_setup(alice, bob, root_gauge):
root_gauge.commit_transfer_ownership(bob, {"from": alice})
def test_admin_updated(root_gauge, bob):
before = root_gauge.admin()
root_gauge.accept_transfer_ownership({"from": bob})
assert before != | bob | assert | variable | tests/unitary/Sidechain/test_accept_transfer_ownership.py | test_admin_updated | 20 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract_2(CurveRewards, mock_lp_token, accounts, coin_a):
contract = CurveRewards.deploy(mock_lp_token, coin_a, {"from": accounts[0]})
contract.s... | REWARD | assert | variable | tests/unitary/LiquidityGaugeV2/test_set_rewards_deposit.py | test_unsetting_claims | 64 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract(RewardStream, alice, charlie, rewards_only_gauge, coin_reward):
contract = RewardStream.deploy(alice, charlie, coin_reward, 86400 * 7, {"from": alice})
... | REWARD | assert | variable | tests/unitary/RewardsOnlyGauge/test_claim_rewards_unipool.py | test_claim_one_lp | 61 | null | |
curvefi/curve-dao-contracts | from collections import defaultdict
import brownie
from brownie import RewardStream, chain
from brownie.test import strategy
from brownie_tokens import ERC20
DAY = 60 * 60 * 24
class _State:
def __init__(self, owner: str, distributor: str, duration: int) -> None:
# public getters in contract
sel... | True | assert | bool_literal | tests/integration/test_reward_stream_state.py | remove_receiver | _State | 80 | null |
curvefi/curve-dao-contracts | import math
import brownie
import pytest
from brownie import ZERO_ADDRESS, compile_source
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
code = """
# @version 0.2.7
from vyper.interfaces import ERC20
first: address
second: address
@external
def __init__(_first: address,... | claimed[1] | assert | complex_expr | tests/unitary/LiquidityGaugeV3/test_claim_rewards_multiple.py | test_claim_duration | 156 | null | |
curvefi/curve-dao-contracts | DAY = 86400
WEEK = 7 * DAY
def test_deposited_after(web3, chain, accounts, voting_escrow, fee_distributor, coin_a, token):
alice, bob = accounts[0:2]
amount = 1000 * 10 ** 18
fee_distributor = fee_distributor()
token.approve(voting_escrow.address, amount * 10, {"from": alice})
coin_a._mint_for_tes... | 0 | assert | numeric_literal | tests/unitary/FeeDistribution/test_fee_distribution.py | test_deposited_after | 29 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def deposit_setup(accounts, liquidity_gauge, mock_lp_token):
mock_lp_token.approve(liquidity_gauge, 2 ** 256 - 1, {"from": accounts[0]})
def test_deposit_zero(accounts, liquidity_gauge, mock_lp_token):
balance = mock_lp_token.balanceOf(accounts[0])
liquidity_gauge.deposit(0, {... | balance | assert | variable | tests/unitary/LiquidityGauge/test_deposit_withdraw.py | test_deposit_zero | 25 | null | |
curvefi/curve-dao-contracts | import pytest
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def initial_setup(accounts, coin_reward, reward_contract, mock_lp_token, liquidity_gauge_reward):
# Fund
coin_reward._mint_for_testing(accounts[0], REWARD)
coin_reward.transfer(reward_contract, REWARD,... | tuple(rewards) | assert | func_call | tests/unitary/LiquidityGaugeReward/test_claim_rewards.py | test_claim_two_lp | 79 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def deposit_setup(accounts, gauge_v2, mock_lp_token):
mock_lp_token.approve(gauge_v2, 2 ** 256 - 1, {"from": accounts[0]})
def test_deposit_zero(accounts, gauge_v2, mock_lp_token):
balance = mock_lp_token.balanceOf(accounts[0])
gauge_v2.deposit(0, {"from": accounts[0]})
a... | balance | assert | variable | tests/unitary/LiquidityGaugeV2/test_deposit_withdraw.py | test_deposit_zero | 25 | null | |
curvefi/curve-dao-contracts | import itertools
import pytest
TYPE_WEIGHTS = [5e17, 1e19]
GAUGE_WEIGHTS = [1e19, 1e18, 5e17]
GAUGE_TYPES = [0, 0, 1]
MONTH = 86400 * 30
WEEK = 7 * 86400
def setup(accounts, mock_lp_token, token, minter, gauge_controller, liquidity_gauge, gauge_wrapper):
token.set_minter(minter, {"from": accounts[0]})
gaug... | balance | assert | variable | tests/unitary/LiquidityGaugeWrapper/test_claim_tokens.py | test_multiple_claims | 72 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import Contract
def burner(IdleBurner, alice, receiver):
yield IdleBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in ctokens], ids=[i[1] for i in ctokens])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.m... | 0 | assert | numeric_literal | tests/fork/Burners/test_idle_burner.py | test_ctoken_unwrap | 37 | null | |
curvefi/curve-dao-contracts | ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
def test_disable_after_end_time(vesting_simple, coin_a, accounts, chain, end_time):
chain.sleep(end_time - chain.time())
vesting_simple.toggle_disable(accounts[1], {"from": accounts[0]})
vesting_simple.claim({"from": accounts[1]})
assert coi... | 10 ** 20 | assert | complex_expr | tests/unitary/VestingEscrowFactory/test_disable_and_claim_simple.py | test_disable_after_end_time | 9 | null | |
curvefi/curve-dao-contracts | from collections import defaultdict
import brownie
from brownie import RewardStream, chain
from brownie.test import strategy
from brownie_tokens import ERC20
DAY = 60 * 60 * 24
class _State:
def __init__(self, owner: str, distributor: str, duration: int) -> None:
# public getters in contract
sel... | self.owner | assert | complex_expr | tests/integration/test_reward_stream_state.py | add_receiver | _State | 68 | null |
curvefi/curve-dao-contracts | import brownie
def test_commit_transfer_ownership(vesting_factory, accounts):
vesting_factory.commit_transfer_ownership(accounts[1], {"from": accounts[0]})
assert vesting_factory.admin() == accounts[0]
assert vesting_factory.future_admin() == | accounts[1] | assert | complex_expr | tests/unitary/VestingEscrowFactory/test_admin_factory.py | test_commit_transfer_ownership | 18 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | [accounts[0], accounts[2], amount] | assert | collection | tests/unitary/LiquidityGaugeRewardWrapper/test_transferFrom.py | test_transfer_event_fires | 199 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(
accounts,
gauge_controller,
minter,
liquidity_gauge_reward,
reward_gauge_wrapper,
token,
mock_lp_token,
):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_cont... | 0 | assert | numeric_literal | tests/unitary/LiquidityGaugeRewardWrapper/test_deposit_withdraw.py | test_deposit | 30 | null | |
curvefi/curve-dao-contracts | import pytest
def burner(MetaBurner, alice, receiver):
yield MetaBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
@pytest.mark.parametrize("token", [i[0] for i in tokens], ids=[i[1] for i in tokens])
@pytest.mark.parametrize("burner_balance", (True, False))
@pytest.mark.parametrize("caller_balance... | 0 | assert | numeric_literal | tests/fork/Burners/test_metaburner.py | test_swap | 40 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def setup(accounts, gauge_controller, minter, gauge_v3, token, mock_lp_token):
token.set_minter(minter, {"from": accounts[0]})
gauge_controller.add_type(b"Liquidity", 10 ** 10, {"from": accounts[0]})
gauge_controller.add_gauge(gauge_v3, 0, 0, {"from": accounts[0]})
mock_l... | [accounts[0], accounts[1], amount] | assert | collection | tests/unitary/LiquidityGaugeV3/test_transfer.py | test_transfer_event_fires | 91 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
from brownie import ZERO_ADDRESS
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
def reward_contract_2(CurveRewards, mock_lp_token, accounts, coin_a):
contract = CurveRewards.deploy(mock_lp_token, coin_a, {"from": accounts[0]})
contract.setRewardDistribution(accounts[0], {... | [coin_reward] + [ZERO_ADDRESS] * 7 | assert | collection | tests/unitary/LiquidityGaugeV3/test_set_rewards_no_deposit.py | test_unset_no_totalsupply | 29 | null | |
curvefi/curve-dao-contracts | import math
import brownie
import pytest
from brownie import ZERO_ADDRESS, compile_source
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
code = """
# @version 0.2.7
from vyper.interfaces import ERC20
first: address
second: address
@external
def __init__(_first: address,... | reward | assert | variable | tests/unitary/RewardsOnlyGauge/test_claim_rewards_multiple.py | test_claim_updates_claimed_reward | 92 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ETH_ADDRESS
def burner(ETHBurner, alice, receiver):
yield ETHBurner.deploy(receiver, receiver, alice, alice, {"from": alice})
def test_swap_ether(MintableTestToken, SUSD, alice, receiver, burner):
burner.burn(ETH_ADDRESS, {"from": alice, "value": "1 ether"})
assert alice... | 0 | assert | numeric_literal | tests/fork/Burners/test_eth_burner.py | test_swap_ether | 49 | null | |
curvefi/curve-dao-contracts | import brownie
import pytest
def deposit_setup(accounts, liquidity_gauge_reward, mock_lp_token):
mock_lp_token.approve(liquidity_gauge_reward, 2 ** 256 - 1, {"from": accounts[0]})
def test_deposit_zero(accounts, liquidity_gauge_reward, mock_lp_token, reward_contract):
balance = mock_lp_token.balanceOf(account... | 0 | assert | numeric_literal | tests/unitary/LiquidityGaugeReward/test_deposit_withdraw_reward.py | test_deposit_zero | 24 | null | |
curvefi/curve-dao-contracts | import pytest
from brownie import ZERO_ADDRESS, compile_source
from tests.conftest import approx
REWARD = 10 ** 20
WEEK = 7 * 86400
LP_AMOUNT = 10 ** 18
code = """
# @version 0.2.7
from vyper.interfaces import ERC20
first: address
second: address
@external
def __init__(_first: address, _second: address):
self... | REWARD | assert | variable | tests/unitary/RewardsOnlyGauge/test_set_rewards_receiver.py | test_claim_one_lp | 79 | null | |
curvefi/curve-dao-contracts | def test_burner(WrappedBurner, WETH, alice, receiver):
initial_balance = receiver.balance()
burner = WrappedBurner.deploy(WETH, receiver, {"from": alice})
amount = 12 * 10 ** 18
WETH._mint_for_testing(alice, amount, {"from": alice})
WETH.approve(burner, 2 ** 256 - 1, {"from": alice})
WETH._mint_... | 0 | assert | numeric_literal | tests/fork/Burners/test_wrapped_burner.py | test_burner | 11 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.