Increase test coverage for the token contract

Author: loredanacirstea

contracts/test/proxy.sol

@@ -4,10 +4,7 @@ import '../ERC223ReceivingContract.sol';
 
 // Contract needed for testing the token contract
 // TODO general function call with 1 data argument in bytes
-contract Proxy is ERC223ReceivingContract{
-    address public sender;
-    uint256 public value;
-    bytes public data;
+contract Proxy{
 
     event Payable(address to, uint value, string function_string);
 
@@ -28,6 +25,14 @@ contract Proxy is ERC223ReceivingContract{
         Payable(to, msg.value, function_string);
         return to.call.value(msg.value)(bytes4(sha3(function_string)));
     }
+}
+
+contract ProxyERC223 is ERC223ReceivingContract{
+    address public sender;
+    uint256 public value;
+    bytes public data;
+
+    function ProxyERC223() {}
 
     function tokenFallback(
         address _from,

contracts/test/tokenTest.sol

@@ -0,0 +1,109 @@
+pragma solidity ^0.4.11;
+
+import '../ERC223ReceivingContract.sol';
+import '../token.sol';
+
+/// @title Custom Token
+contract CustomToken2 is StandardToken {
+
+    /*
+     *  Terminology:
+     *  1 token unit = Tei
+     *  1 token = TKN = Tei * multiplier
+     *  multiplier set from token's number of decimals (i.e. 10**decimals)
+     */
+
+    /*
+     *  Token metadata
+     */
+    string constant public name = "The Token";
+    string constant public symbol = "TKN";
+    uint8 public decimals;
+    uint multiplier;
+
+    address public owner;
+    address public auction_address;
+
+    event Deployed(
+        address indexed _auction,
+        uint indexed _total_supply,
+        uint indexed _auction_supply);
+    event Burnt(
+        address indexed _receiver,
+        uint indexed _num,
+        uint indexed _total_supply);
+
+    /*
+     *  Public functions
+     */
+    /// @dev Contract constructor function sets dutch auction contract address and assigns all tokens to dutch auction.
+    /// @param auction Address of dutch auction contract.
+    /// @param initial_supply Number of initially provided token units (Tei).
+    /// @param owners Array of addresses receiving preassigned tokens.
+    /// @param tokens Array of preassigned token units (Tei).
+    function CustomToken2(
+        uint8 _decimals,
+        address auction,
+        uint initial_supply,
+        address[] owners,
+        uint[] tokens)
+        public
+    {
+        // Auction address should not be null.
+        require(auction != 0x0);
+        require(owners.length == tokens.length);
+        // Initial supply is in Tei
+        require(initial_supply > multiplier);
+
+        owner = msg.sender;
+        auction_address = auction;
+        decimals = _decimals;
+        multiplier = 10**uint(decimals);
+
+        // Total supply of Tei at deployment
+        totalSupply = initial_supply;
+
+        // Preallocate tokens to beneficiaries
+        uint prealloc_tokens;
+        for (uint i=0; i<owners.length; i++) {
+            // Address should not be null.
+            require(owners[i] != 0x0);
+            require(tokens[i] > 0);
+            require(balances[owners[i]] + tokens[i] > balances[owners[i]]);
+            require(prealloc_tokens + tokens[i] > prealloc_tokens);
+
+            balances[owners[i]] += tokens[i];
+            prealloc_tokens += tokens[i];
+            Transfer(0, owners[i], tokens[i]);
+        }
+
+        balances[auction_address] = totalSupply - prealloc_tokens;
+        Transfer(0, auction_address, balances[auction]);
+
+        Deployed(auction_address, totalSupply, balances[auction]);
+
+        assert(balances[auction_address] > 0);
+        assert(balances[auction_address] < totalSupply);
+        assert(totalSupply == balances[auction_address] + prealloc_tokens);
+    }
+
+    /// @notice Allows `msg.sender` to simply destroy `num` token units (Tei), without receiving the corresponding amount of ether. This means the total token supply will decrease.
+    /// @dev Allows to destroy token units (Tei) without receiving the corresponding amount of ether.
+    /// @param num Number of token units (Tei) to burn.
+    function burn(uint num)
+        public
+    {
+        require(num > 0);
+        require(balances[msg.sender] >= num);
+        require(totalSupply >= num);
+
+        uint pre_balance = balances[msg.sender];
+
+        balances[msg.sender] -= num;
+        totalSupply -= num;
+        Burnt(msg.sender, num, totalSupply);
+
+        assert(balances[msg.sender] == pre_balance - num);
+    }
+
+}

tests/fixtures.py

@@ -1,4 +1,5 @@
 import pytest
+from eth_utils import decode_hex, keccak
 from functools import (
     reduce
 )
@@ -8,8 +9,12 @@
 )
 
 
+MAX_UINT = 2**256
+fake_address = 0x03432
 print_the_logs = False
 passphrase = '0'
+fixture_decimals = [18, 1]
+
 
 contract_args = [
     {
@@ -28,8 +33,15 @@
     }
 ]
 
-'''
+
 contract_args += [
+    {
+        'token': 'CustomToken2',
+        'decimals': 1,
+        'supply': 10000000,
+        'preallocations': [200000, 800000],
+        'args': [5982, 59]
+    },
     {
         'token': 'CustomToken2',
         'decimals': 1,
@@ -38,10 +50,14 @@
         'args': [10000, 7500]
     }
 ]
-'''
+
 
 # auction_supply = initial_supply - reduce((lambda x, y: x + y), prealloc)
 
+def test_bytes(value=10, size=256):
+    hex_value = decode_hex('{:x}'.format(value).zfill(size // 4))
+    return keccak(hex_value)
+
 
 def prepare_preallocs(multiplier, preallocs):
     return list(map(lambda x: x * multiplier, preallocs))
@@ -55,15 +71,17 @@ def owner(web3):
 @pytest.fixture()
 def team(web3, contract_params):
     index_end = len(contract_params['preallocations']) + 1
-    return web3.eth.accounts[1:index_end]
-
+    return web3.eth.accounts[2:(index_end + 1)]
 
 @pytest.fixture()
 def get_bidders(web3, contract_params, create_accounts):
     def get_these_bidders(number):
-        index_start = 2+ len(contract_params['preallocations'])
-        bidders = web3.eth.accounts[index_start:]
-        bidders += create_accounts(number - len(bidders))
+        index_start = 2 + len(contract_params['preallocations'])
+        accounts_len = len(web3.eth.accounts)
+        index_end = min(number + index_start, accounts_len)
+        bidders = web3.eth.accounts[index_start:index_end]
+        if number > len(bidders):
+            bidders += create_accounts(number - len(bidders))
         return bidders
     return get_these_bidders
 
@@ -116,11 +134,15 @@ def auction_contract(
 @pytest.fixture()
 def get_token_contract(chain, create_contract, owner):
     # contract can be auction contract or proxy contract
-    def get(arguments, transaction=None, token_type='CustomToken'):
+    def get(arguments, transaction=None, token_type='CustomToken', decimals=18):
+        if not decimals == 18:
+            token_type = 'CustomToken2'
+            arguments.insert(0, decimals)
+
         CustomToken = chain.provider.get_contract_factory(token_type)
         if not transaction:
             transaction = {'from': owner}
-
+        # print('get_token_contract token_type', token_type, decimals, arguments)
         token_contract = create_contract(CustomToken, arguments, transaction)
 
         if print_the_logs:
@@ -138,6 +160,7 @@ def token_contract(
     chain,
     web3,
     owner,
+    team,
     contract_params,
     get_token_contract):
     decimals = contract_params['decimals']
@@ -146,23 +169,15 @@ def token_contract(
     supply = contract_params['supply'] * multiplier
     token_type = contract_params['token']
 
-    owners = web3.eth.accounts[2:(len(preallocations) + 2)]
-
     def get(auction_address, transaction=None):
-        args = []
-
-        if token_type == 'CustomToken2':
-            args.append(decimals)
-
-        args += [
+        args = [
             auction_address,
             supply,
-            owners,
+            team,
             prepare_preallocs(multiplier, preallocations)
         ]
-        if not transaction:
-            transaction = {'from': owner}
-        token_contract = get_token_contract(args, transaction, token_type)
+
+        token_contract = get_token_contract(args, transaction, token_type, decimals)
 
         return token_contract
     return get