lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #2705 from chriseth/sol_auctionRegistrarTests 

Basic tests for auction registrar.
cl-refactor
Gav Wood 10 years ago
parent
3e15e96dcc 6d101eb020
commit
ad70019e2b
3 changed files with 487 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 418
      test/contracts/AuctionRegistrar.cpp
  2. 5
      test/contracts/FixedFeeRegistrar.cpp
  3. 64
      test/libsolidity/solidityExecutionFramework.h

418
test/contracts/AuctionRegistrar.cpp
View File

@ -0,0 +1,418 @@
/*
This file is part of cpp-ethereum.
cpp-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
cpp-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author Christian <c@ethdev.com>
* @date 2015
* Tests for a fixed fee registrar contract.
*/
#include <string>
#include <tuple>
#include <boost/test/unit_test.hpp>
#include <libdevcore/Hash.h>
#include <libethcore/ABI.h>
#include <test/libsolidity/solidityExecutionFramework.h>
using namespace std;
namespace dev
{
namespace solidity
{
namespace test
{
namespace
{
static char const* registrarCode = R"DELIMITER(
//sol
contract NameRegister {
function addr(string _name) constant returns (address o_owner);
function name(address _owner) constant returns (string o_name);
}
contract Registrar is NameRegister {
event Changed(string indexed name);
event PrimaryChanged(string indexed name, address indexed addr);
function owner(string _name) constant returns (address o_owner);
function addr(string _name) constant returns (address o_address);
function subRegistrar(string _name) constant returns (address o_subRegistrar);
function content(string _name) constant returns (bytes32 o_content);
function name(address _owner) constant returns (string o_name);
}
contract AuctionSystem {
event AuctionEnded(string indexed _name, address _winner);
event NewBid(string indexed _name, address _bidder, uint _value);
/// Function that is called once an auction ends.
function onAuctionEnd(string _name) internal;
function bid(string _name, address _bidder, uint _value) internal {
var auction = m_auctions[_name];
if (auction.endDate > 0 && now > auction.endDate)
{
AuctionEnded(_name, auction.highestBidder);
onAuctionEnd(_name);
delete m_auctions[_name];
return;
}
if (msg.value > auction.highestBid)
{
// new bid on auction
auction.secondHighestBid = auction.highestBid;
auction.sumOfBids += _value;
auction.highestBid = _value;
auction.highestBidder = _bidder;
auction.endDate = now + c_biddingTime;
NewBid(_name, _bidder, _value);
}
}
uint constant c_biddingTime = 7 days;
struct Auction {
address highestBidder;
uint highestBid;
uint secondHighestBid;
uint sumOfBids;
uint endDate;
}
mapping(string => Auction) m_auctions;
}
contract GlobalRegistrar is Registrar, AuctionSystem {
struct Record {
address owner;
address primary;
address subRegistrar;
bytes32 content;
uint renewalDate;
}
uint constant c_renewalInterval = 1 years;
uint constant c_freeBytes = 12;
function Registrar() {
// TODO: Populate with hall-of-fame.
}
function() {
// prevent people from just sending funds to the registrar
__throw();
}
function onAuctionEnd(string _name) internal {
var auction = m_auctions[_name];
var record = m_toRecord[_name];
if (record.owner != 0)
record.owner.send(auction.sumOfBids - auction.highestBid / 100);
else
auction.highestBidder.send(auction.highestBid - auction.secondHighestBid);
record.renewalDate = now + c_renewalInterval;
record.owner = auction.highestBidder;
Changed(_name);
}
function reserve(string _name) external {
if (bytes(_name).length == 0)
__throw();
bool needAuction = requiresAuction(_name);
if (needAuction)
{
if (now < m_toRecord[_name].renewalDate)
__throw();
bid(_name, msg.sender, msg.value);
}
else
{
Record record = m_toRecord[_name];
if (record.owner != 0)
__throw();
m_toRecord[_name].owner = msg.sender;
Changed(_name);
}
}
function requiresAuction(string _name) internal returns (bool) {
return bytes(_name).length < c_freeBytes;
}
modifier onlyrecordowner(string _name) { if (m_toRecord[_name].owner == msg.sender) _ }
function transfer(string _name, address _newOwner) onlyrecordowner(_name) {
m_toRecord[_name].owner = _newOwner;
Changed(_name);
}
function disown(string _name) onlyrecordowner(_name) {
if (stringsEqual(m_toName[m_toRecord[_name].primary], _name))
{
PrimaryChanged(_name, m_toRecord[_name].primary);
m_toName[m_toRecord[_name].primary] = "";
}
delete m_toRecord[_name];
Changed(_name);
}
function setAddress(string _name, address _a, bool _primary) onlyrecordowner(_name) {
m_toRecord[_name].primary = _a;
if (_primary)
{
PrimaryChanged(_name, _a);
m_toName[_a] = _name;
}
Changed(_name);
}
function setSubRegistrar(string _name, address _registrar) onlyrecordowner(_name) {
m_toRecord[_name].subRegistrar = _registrar;
Changed(_name);
}
function setContent(string _name, bytes32 _content) onlyrecordowner(_name) {
m_toRecord[_name].content = _content;
Changed(_name);
}
function stringsEqual(string storage _a, string memory _b) internal returns (bool) {
bytes storage a = bytes(_a);
bytes memory b = bytes(_b);
if (a.length != b.length)
return false;
// @todo unroll this loop
for (uint i = 0; i < a.length; i ++)
if (a[i] != b[i])
return false;
return true;
}
function owner(string _name) constant returns (address) { return m_toRecord[_name].owner; }
function addr(string _name) constant returns (address) { return m_toRecord[_name].primary; }
function subRegistrar(string _name) constant returns (address) { return m_toRecord[_name].subRegistrar; }
function content(string _name) constant returns (bytes32) { return m_toRecord[_name].content; }
function name(address _addr) constant returns (string o_name) { return m_toName[_addr]; }
function __throw() internal {
// workaround until we have "throw"
uint[] x; x[1];
}
mapping (address => string) m_toName;
mapping (string => Record) m_toRecord;
}
)DELIMITER";
static unique_ptr<bytes> s_compiledRegistrar;
class AuctionRegistrarTestFramework: public ExecutionFramework
{
protected:
void deployRegistrar()
{
if (!s_compiledRegistrar)
{
m_optimize = true;
m_compiler.reset(false, m_addStandardSources);
m_compiler.addSource("", registrarCode);
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize, m_optimizeRuns), "Compiling contract failed");
s_compiledRegistrar.reset(new bytes(m_compiler.getBytecode("GlobalRegistrar")));
}
sendMessage(*s_compiledRegistrar, true);
BOOST_REQUIRE(!m_output.empty());
}
using ContractInterface = ExecutionFramework::ContractInterface;
class RegistrarInterface: public ContractInterface
{
public:
RegistrarInterface(ExecutionFramework& _framework): ContractInterface(_framework) {}
void reserve(string const& _name)
{
callString("reserve", _name);
}
u160 owner(string const& _name)
{
return callStringReturnsAddress("owner", _name);
}
void setAddress(string const& _name, u160 const& _address, bool _primary)
{
callStringAddressBool("setAddress", _name, _address, _primary);
}
u160 addr(string const& _name)
{
return callStringReturnsAddress("addr", _name);
}
string name(u160 const& _addr)
{
return callAddressReturnsString("name", _addr);
}
void setSubRegistrar(string const& _name, u160 const& _address)
{
callStringAddress("setSubRegistrar", _name, _address);
}
u160 subRegistrar(string const& _name)
{
return callStringReturnsAddress("subRegistrar", _name);
}
void setContent(string const& _name, h256 const& _content)
{
callStringBytes32("setContent", _name, _content);
}
h256 content(string const& _name)
{
return callStringReturnsBytes32("content", _name);
}
void transfer(string const& _name, u160 const& _target)
{
return callStringAddress("transfer", _name, _target);
}
void disown(string const& _name)
{
return callString("disown", _name);
}
};
};
}
/// This is a test suite that tests optimised code!
BOOST_FIXTURE_TEST_SUITE(SolidityAuctionRegistrar, AuctionRegistrarTestFramework)
BOOST_AUTO_TEST_CASE(creation)
{
deployRegistrar();
}
BOOST_AUTO_TEST_CASE(reserve)
{
// Test that reserving works for long strings
deployRegistrar();
vector<string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
// should not work
registrar.reserve("");
BOOST_CHECK_EQUAL(registrar.owner(""), u160(0));
for (auto const& name: names)
{
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
}
}
BOOST_AUTO_TEST_CASE(double_reserve_long)
{
// Test that it is not possible to re-reserve from a different address.
deployRegistrar();
string name = "abcabcabcabcabcabcabcabcabcabca";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
m_sender = Address(0x124);
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(0x123));
}
BOOST_AUTO_TEST_CASE(properties)
{
// Test setting and retrieving the various properties works.
deployRegistrar();
RegistrarInterface registrar(*this);
string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
size_t addr = 0x9872543;
for (string const& name: names)
{
addr++;
size_t sender = addr + 10007;
m_sender = Address(sender);
// setting by sender works
registrar.reserve(name);
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender));
registrar.setAddress(name, addr, true);
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
registrar.setSubRegistrar(name, addr + 20);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
registrar.setContent(name, h256(u256(addr + 90)));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
// but not by someone else
m_sender = Address(h256(addr + 10007 - 1));
BOOST_CHECK_EQUAL(registrar.owner(name), u160(sender));
registrar.setAddress(name, addr + 1, true);
BOOST_CHECK_EQUAL(registrar.addr(name), u160(addr));
registrar.setSubRegistrar(name, addr + 20 + 1);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), u160(addr + 20));
registrar.setContent(name, h256(u256(addr + 90 + 1)));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
}
}
BOOST_AUTO_TEST_CASE(transfer)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
registrar.setContent(name, h256(u256(123)));
registrar.transfer(name, u160(555));
BOOST_CHECK_EQUAL(registrar.owner(name), u160(555));
BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(123)));
}
BOOST_AUTO_TEST_CASE(disown)
{
deployRegistrar();
string name = "abcaoeguaoucaeoduceo";
m_sender = Address(0x123);
RegistrarInterface registrar(*this);
registrar.reserve(name);
registrar.setContent(name, h256(u256(123)));
registrar.setAddress(name, u160(124), true);
registrar.setSubRegistrar(name, u160(125));
// someone else tries disowning
m_sender = Address(0x128);
registrar.disown(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0x123);
m_sender = Address(0x123);
registrar.disown(name);
BOOST_CHECK_EQUAL(registrar.owner(name), 0);
BOOST_CHECK_EQUAL(registrar.addr(name), 0);
BOOST_CHECK_EQUAL(registrar.subRegistrar(name), 0);
BOOST_CHECK_EQUAL(registrar.content(name), h256());
}
//@todo:
// - reverse lookup
// - actual auction
BOOST_AUTO_TEST_SUITE_END()
}
}
} // end namespaces

5
test/contracts/FixedFeeRegistrar.cpp
View File

@ -35,6 +35,9 @@ namespace solidity
namespace test namespace test
{ {
namespace
{
static char const* registrarCode = R"DELIMITER( static char const* registrarCode = R"DELIMITER(
//sol FixedFeeRegistrar //sol FixedFeeRegistrar
// Simple global registrar with fixed-fee reservations. // Simple global registrar with fixed-fee reservations.
@ -130,6 +133,8 @@ protected:
u256 const m_fee = u256("69000000000000000000"); u256 const m_fee = u256("69000000000000000000");
}; };
}
/// This is a test suite that tests optimised code! /// This is a test suite that tests optimised code!
BOOST_FIXTURE_TEST_SUITE(SolidityFixedFeeRegistrar, RegistrarTestFramework) BOOST_FIXTURE_TEST_SUITE(SolidityFixedFeeRegistrar, RegistrarTestFramework)

64
test/libsolidity/solidityExecutionFramework.h
View File

@ -25,6 +25,7 @@
#include <string> #include <string>
#include <tuple> #include <tuple>
#include "../TestHelper.h" #include "../TestHelper.h"
#include <libethcore/ABI.h>
#include <libethereum/State.h> #include <libethereum/State.h>
#include <libethereum/Executive.h> #include <libethereum/Executive.h>
#include <libsolidity/CompilerStack.h> #include <libsolidity/CompilerStack.h>
@ -165,6 +166,69 @@ public:
return encodeArgs(u256(0x20), u256(_arg.size()), _arg); return encodeArgs(u256(0x20), u256(_arg.size()), _arg);
} }
class ContractInterface
{
public:
ContractInterface(ExecutionFramework& _framework): m_framework(_framework) {}
protected:
template <class... Args>
bytes const& call(std::string const& _sig, Args const&... _arguments)
{
auto const& ret = m_framework.callContractFunctionWithValue(_sig, m_nextValue, _arguments...);
m_nextValue = 0;
return ret;
}
void callString(std::string const& _name, std::string const& _arg)
{
BOOST_CHECK(call(_name + "(string)", u256(0x20), _arg.length(), _arg).empty());
}
void callStringAddress(std::string const& _name, std::string const& _arg1, u160 const& _arg2)
{
BOOST_CHECK(call(_name + "(string,address)", u256(0x40), _arg2, _arg1.length(), _arg1).empty());
}
void callStringAddressBool(std::string const& _name, std::string const& _arg1, u160 const& _arg2, bool _arg3)
{
BOOST_CHECK(call(_name + "(string,address,bool)", u256(0x60), _arg2, _arg3, _arg1.length(), _arg1).empty());
}
void callStringBytes32(std::string const& _name, std::string const& _arg1, h256 const& _arg2)
{
BOOST_CHECK(call(_name + "(string,bytes32)", u256(0x40), _arg2, _arg1.length(), _arg1).empty());
}
u160 callStringReturnsAddress(std::string const& _name, std::string const& _arg)
{
bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg);
BOOST_REQUIRE(ret.size() == 0x20);
BOOST_CHECK(std::count(ret.begin(), ret.begin() + 12, 0) == 12);
return eth::abiOut<u160>(ret);
}
std::string callAddressReturnsString(std::string const& _name, u160 const& _arg)
{
bytes const& ret = call(_name + "(address)", _arg);
BOOST_REQUIRE(ret.size() >= 0x20);
u256 len = eth::abiOut<u256>(ret);
BOOST_REQUIRE(ret.size() == (0x20 + len) / 32 * 32);
return std::string(ret.begin() + 0x20, ret.begin() + 0x20 + size_t(len));
}
h256 callStringReturnsBytes32(std::string const& _name, std::string const& _arg)
{
bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg);
BOOST_REQUIRE(ret.size() == 0x20);
return eth::abiOut<h256>(ret);
}
private:
u256 m_nextValue;
ExecutionFramework& m_framework;
};
private: private:
template <class CppFunction, class... Args> template <class CppFunction, class... Args>
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)

Write Preview
Loading…
Cancel
Save