fuzzHelper.h

Go to the documentation of this file.

/*
        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/>.
*/
#include <string>
#include <boost/random.hpp>
#include <boost/filesystem/path.hpp>

#include <test/libtesteth/TestHelper.h>
#include <libdevcore/CommonIO.h>
#include <libdevcore/CommonData.h>
#include <libevmcore/Instruction.h>

#pragma once

namespace dev
{
namespace test
{

typedef boost::random::uniform_int_distribution<> boostIntDistrib;
typedef boost::random::discrete_distribution<> boostDescreteDistrib;
typedef boost::uniform_int<uint64_t> boostUint64Distrib;

typedef boost::random::variate_generator<boost::mt19937&, boostIntDistrib > boostIntGenerator;
typedef boost::random::variate_generator<boost::mt19937&, boostDescreteDistrib > boostWeightGenerator;
typedef boost::random::variate_generator<boost::mt19937&, boostUint64Distrib > boostUInt64Generator;

struct RandomCodeOptions
{
public:
        RandomCodeOptions();
        void setWeight(dev::eth::Instruction _opCode, int _weight);
        void addAddress(dev::Address const& _address);
        dev::Address getRandomAddress() const;

        bool useUndefinedOpCodes;
        int smartCodeProbability;
        boostDescreteDistrib opCodeProbability;
private:
        void setWeights();
        std::map<int, int> mapWeights;
        std::vector<dev::Address> addressList;
};

enum class SizeStrictness
{
        Strict,
        Random
};

struct RlpDebug
{
        std::string rlp;
        int insertions;
};

class RandomCode
{
public:
        static std::string generate(int _maxOpNumber = 1, RandomCodeOptions _options = RandomCodeOptions());

        static void parseTestWithTypes(std::string& _test, std::map<std::string, std::string> const& _varMap);

        static std::string rndByteSequence(int _length = 1, SizeStrictness _sizeType = SizeStrictness::Strict);

        static std::string rndRLPSequence(int _depth, std::string& _debug);

        static std::string randomUniIntHex(u256 _maxVal = 0);
        static u256 randomUniInt(u256 _maxVal = 0);

private:
        static std::string fillArguments(dev::eth::Instruction _opcode, RandomCodeOptions const& _options);
        static std::string getPushCode(int _value);
        static std::string getPushCode(std::string const& _hex);
        static int recursiveRLP(std::string& _result, int _depth, std::string& _debug);
        static void refreshSeed();
        static std::vector<std::string> getTypes();

        static boost::random::mt19937 gen;                      
        static boostIntDistrib opCodeDist;                      
        static boostIntDistrib opLengDist;                      
        static boostIntDistrib uniIntDist;          
        static boostUint64Distrib uInt64Dist;           

        static boostIntGenerator randUniIntGen;         
        static boostIntGenerator randOpCodeGen;         
        static boostIntGenerator randOpLengGen;         
        static boostUInt64Generator randUInt64Gen;      
};

}
}