View Source
const UpsieDownsieCallCount = 1 + (34 - 17) + 1 + (34 - 23)

    Recursive call count for UpsieDownsie() function call from strange_loop.sol Equals initial call, then depth from 17 -> 34, one for the bounce, then depth from 34 -> 23, so... (I didn't say it had to make sense):


    View Source
    var PrivateAccounts = integration.MakePrivateAccounts("mysecret", 10) // make keys


    func CallContract

    func CallContract(cli rpctransact.TransactClient, inputAddress, contractAddress crypto.Address, data []byte) (*exec.TxExecution, error)

    func CreateContract

    func CreateContract(cli rpctransact.TransactClient, inputAddress crypto.Address, bytecode []byte, metamap []MetadataMap) (*exec.TxExecution, error)

    func DumpStorage

    func DumpStorage(t *testing.T, client infoclient.RPCClient, addr crypto.Address) *rpc.ResultDumpStorage

      dump all storage for an account. currently unused

      func GetAccount

      func GetAccount(t *testing.T, client infoclient.RPCClient, addr crypto.Address) *acm.Account

        get the account

        func GetSequence

        func GetSequence(t *testing.T, client infoclient.RPCClient, addr crypto.Address) uint64

          get an account's sequence number

          func GetStorage

          func GetStorage(t *testing.T, client infoclient.RPCClient, addr crypto.Address, key []byte) []byte

          func MakeDefaultCallTx

          func MakeDefaultCallTx(t *testing.T, client infoclient.RPCClient, addr *crypto.Address, code []byte, amt, gasLim,
          	fee uint64) *txs.Envelope

          func NewExecutionEventsClient

          func NewExecutionEventsClient(t testing.TB, listenAddress string) rpcevents.ExecutionEventsClient

          func NewQueryClient

          func NewQueryClient(t testing.TB, listenAddress string) rpcquery.QueryClient

          func NewTransactClient

          func NewTransactClient(t testing.TB, listenAddress string) rpctransact.TransactClient


            func UpdateName

            func UpdateName(cli rpctransact.TransactClient, inputAddress crypto.Address, name, data string,
            	expiresIn uint64) (*exec.TxExecution, error)

            func WaitNBlocks

            func WaitNBlocks(ecli rpcevents.ExecutionEventsClient, n int) (rerr error)


            type MetadataMap

            type MetadataMap struct {
            	DeployedCode []byte
            	Abi          []byte

            type TxExpecter

            type TxExpecter struct {
            	// contains filtered or unexported fields

            func ExpectTxs

            func ExpectTxs(emitter *event.Emitter, name string) *TxExpecter

              Start listening for blocks and cross off any transactions that were expected. Expect can be called multiple times before a single call to AssertCommitted. TxExpecter is single-shot - create multiple TxExpecters if you want to call AssertCommitted multiple times.

              func (*TxExpecter) AssertCommitted

              func (exp *TxExpecter) AssertCommitted(t testing.TB) *rpcevents.BlockRange

                Assert that all expected transactions are committed. Will block until all expected transactions are committed. Returns the BlockRange over which the transactions were committed.

                func (*TxExpecter) Expect

                func (exp *TxExpecter) Expect(txHash binary.HexBytes)

                  Expect a transaction to be committed

                  func (*TxExpecter) Pass

                  func (exp *TxExpecter) Pass() *rpcevents.BlockRange