Merge remote-tracking branch 'up/develop' into bugFix

cmake/EthCompilerSettings.cmake

@@ -63,6 +63,13 @@ if (PROFILING AND (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_C
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lprofiler")
 endif ()
 
+if (PROFILING AND (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")))
+        set(CMAKE_CXX_FLAGS "-g --coverage ${CMAKE_CXX_FLAGS}")
+        set(CMAKE_C_FLAGS "-g --coverage ${CMAKE_C_FLAGS}")
+        set(CMAKE_SHARED_LINKER_FLAGS "--coverage ${CMAKE_SHARED_LINKER_FLAGS} -lprofiler")
+        set(CMAKE_EXE_LINKER_FLAGS "--coverage ${CMAKE_EXE_LINKER_FLAGS} -lprofiler")
+endif ()
+
 if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
 	option(USE_LD_GOLD "Use GNU gold linker" ON)
 	if (USE_LD_GOLD)

getcoverage.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+CPP_ETHEREUM_PATH=$(pwd)
+BUILD_DIR=$CPP_ETHEREUM_PATH/build
+TEST_MODE=""
+
+for i in "$@"
+do
+case $i in
+	-builddir)
+	shift
+	((i++))
+	BUILD_DIR=${!i}
+	shift 
+	;;
+	--all)
+	TEST_MODE="--all"
+	shift 
+	;;
+esac
+done
+
+which $BUILD_DIR/test/testeth >/dev/null 2>&1
+if [ $? != 0 ]
+then
+	echo "You need to compile and build ethereum with cmake -DPROFILING option to the build dir!"
+	exit;
+fi
+
+OUTPUT_DIR=$BUILD_DIR/test/coverage
+if which lcov >/dev/null; then
+	if which genhtml >/dev/null; then
+		echo Cleaning previous report...
+		if [ -d "$OUTPUT_DIR" ]; then
+			rm -r $OUTPUT_DIR
+		fi
+		mkdir $OUTPUT_DIR
+		lcov --directory $BUILD_DIR --zerocounters
+		lcov --capture --initial --directory $BUILD_DIR --output-file $OUTPUT_DIR/coverage_base.info
+
+		echo Running testeth...
+		$CPP_ETHEREUM_PATH/build/test/testeth $TEST_MODE
+		$CPP_ETHEREUM_PATH/build/test/testeth -t StateTests --jit $TEST_MODE
+		$CPP_ETHEREUM_PATH/build/test/testeth -t VMTests --jit $TEST_MODE
+
+		echo Prepearing coverage info...
+		lcov --capture --directory $BUILD_DIR --output-file $OUTPUT_DIR/coverage_test.info
+		lcov --add-tracefile $OUTPUT_DIR/coverage_base.info --add-tracefile $OUTPUT_DIR/coverage_test.info --output-file $OUTPUT_DIR/coverage_all.info
+		lcov --extract $OUTPUT_DIR/coverage_all.info *cpp-ethereum/* --output-file $OUTPUT_DIR/coverage_export.info
+		genhtml $OUTPUT_DIR/coverage_export.info --output-directory $OUTPUT_DIR/testeth		
+	else
+		echo genhtml not found
+		exit;
+	fi
+else
+	echo lcov not found
+	exit;
+fi
+
+echo "Coverage info should be located at: $OUTPUT_DIR/testeth"
+echo "Opening index..."
+
+xdg-open $OUTPUT_DIR/testeth/index.html &

libdevcore/vector_ref.h

@@ -9,6 +9,9 @@
 namespace dev
 {
 
+/**
+ * A modifiable reference to an existing object or vector in memory.
+ */
 template <class _T>
 class vector_ref
 {
@@ -17,34 +20,50 @@ public:
 	using element_type = _T;
 	using mutable_value_type = typename std::conditional<std::is_const<_T>::value, typename std::remove_const<_T>::type, _T>::type;
 
+	static_assert(std::is_pod<value_type>::value, "vector_ref can only be used with PODs due to its low-level treatment of data.");
+
 	vector_ref(): m_data(nullptr), m_count(0) {}
+	/// Creates a new vector_ref to point to @a _count elements starting at @a _data.
 	vector_ref(_T* _data, size_t _count): m_data(_data), m_count(_count) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as pointer).
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const*, std::string*>::type _data): m_data(reinterpret_cast<_T*>(_data->data())), m_count(_data->size() / sizeof(_T)) {}
+	/// Creates a new vector_ref pointing to the data part of a vector (given as pointer).
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::vector<typename std::remove_const<_T>::type> const*, std::vector<_T>*>::type _data): m_data(_data->data()), m_count(_data->size()) {}
-	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data((_T*)_data.data()), m_count(_data.size() / sizeof(_T)) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as reference).
+	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data(reinterpret_cast<_T*>(_data.data())), m_count(_data.size() / sizeof(_T)) {}
 #ifdef STORAGE_LEVELDB_INCLUDE_DB_H_
 	vector_ref(leveldb::Slice const& _s): m_data(reinterpret_cast<_T*>(_s.data())), m_count(_s.size() / sizeof(_T)) {}
 #endif
 	explicit operator bool() const { return m_data && m_count; }
 
-	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count); }
+	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { if (!m_data || m_count == 0) return _c.empty(); else return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count * sizeof(_T)); }
 	std::vector<mutable_value_type> toVector() const { return std::vector<mutable_value_type>(m_data, m_data + m_count); }
 	std::vector<unsigned char> toBytes() const { return std::vector<unsigned char>(reinterpret_cast<unsigned char const*>(m_data), reinterpret_cast<unsigned char const*>(m_data) + m_count * sizeof(_T)); }
 	std::string toString() const { return std::string((char const*)m_data, ((char const*)m_data) + m_count * sizeof(_T)); }
+
 	template <class _T2> explicit operator vector_ref<_T2>() const { assert(m_count * sizeof(_T) / sizeof(_T2) * sizeof(_T2) / sizeof(_T) == m_count); return vector_ref<_T2>(reinterpret_cast<_T2*>(m_data), m_count * sizeof(_T) / sizeof(_T2)); }
 	operator vector_ref<_T const>() const { return vector_ref<_T const>(m_data, m_count); }
 
 	_T* data() const { return m_data; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
 	size_t count() const { return m_count; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
 	size_t size() const { return m_count; }
 	bool empty() const { return !m_count; }
-	vector_ref<_T> next() const { return vector_ref<_T>(m_data + m_count, m_count); }
+	/// @returns a new vector_ref pointing at the next chunk of @a size() elements.
+	vector_ref<_T> next() const { if (!m_data) return *this; else return vector_ref<_T>(m_data + m_count, m_count); }
+	/// @returns a new vector_ref which is a shifted and shortened view of the original data.
+	/// If this goes out of bounds in any way, returns an empty vector_ref.
+	/// If @a _count is ~size_t(0), extends the view to the end of the data.
 	vector_ref<_T> cropped(size_t _begin, size_t _count) const { if (m_data && _begin + _count <= m_count) return vector_ref<_T>(m_data + _begin, _count == ~size_t(0) ? m_count - _begin : _count); else return vector_ref<_T>(); }
+	/// @returns a new vector_ref which is a shifted view of the original data (not going beyond it).
 	vector_ref<_T> cropped(size_t _begin) const { if (m_data && _begin <= m_count) return vector_ref<_T>(m_data + _begin, m_count - _begin); else return vector_ref<_T>(); }
 	void retarget(_T* _d, size_t _s) { m_data = _d; m_count = _s; }
 	void retarget(std::vector<_T> const& _t) { m_data = _t.data(); m_count = _t.size(); }
 	template <class T> bool overlapsWith(vector_ref<T> _t) const { void const* f1 = data(); void const* t1 = data() + size(); void const* f2 = _t.data(); void const* t2 = _t.data() + _t.size(); return f1 < t2 && t1 > f2; }
+	/// Copies the contents of this vector_ref to the contents of @a _t, up to the max size of @a _t.
 	void copyTo(vector_ref<typename std::remove_const<_T>::type> _t) const { if (overlapsWith(_t)) memmove(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); else memcpy(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); }
+	/// Copies the contents of this vector_ref to the contents of @a _t, and zeros further trailing elements in @a _t.
 	void populate(vector_ref<typename std::remove_const<_T>::type> _t) const { copyTo(_t); memset(_t.data() + m_count, 0, std::max(_t.size(), m_count) - m_count); }
 
 	_T* begin() { return m_data; }

libdevcrypto/AES.h

@@ -76,6 +76,8 @@ public:
 	/// Adjust mac interval. Next mac will be xored with value.
 	void adjustInterval(unsigned _interval) { m_macInterval = _interval; }
 
+	unsigned getMacInterval() { return m_macInterval;}
+	
 private:
 	AuthenticatedStream(AuthenticatedStream const&) = delete;
 	AuthenticatedStream& operator=(AuthenticatedStream const&) = delete;

libevmasm/Assembly.cpp

@@ -292,16 +292,6 @@ void Assembly::injectStart(AssemblyItem const& _i)
 	m_items.insert(m_items.begin(), _i);
 }
 
-inline bool matches(AssemblyItemsConstRef _a, AssemblyItemsConstRef _b)
-{
-	if (_a.size() != _b.size())
-		return false;
-	for (unsigned i = 0; i < _a.size(); ++i)
-		if (!_a[i].match(_b[i]))
-			return false;
-	return true;
-}
-
 struct OptimiserChannel: public LogChannel { static const char* name() { return "OPT"; } static const int verbosity = 12; };
 #define copt dev::LogOutputStream<OptimiserChannel, true>()
 

libevmasm/AssemblyItem.cpp

@@ -126,10 +126,3 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item)
 	}
 	return _out;
 }
-
-ostream& dev::eth::operator<<(ostream& _out, AssemblyItemsConstRef _i)
-{
-	for (AssemblyItem const& i: _i)
-		_out << i;
-	return _out;
-}

libevmasm/AssemblyItem.h

@@ -98,11 +98,14 @@ private:
 };
 
 using AssemblyItems = std::vector<AssemblyItem>;
-using AssemblyItemsConstRef = vector_ref<AssemblyItem const>;
 
 std::ostream& operator<<(std::ostream& _out, AssemblyItem const& _item);
-std::ostream& operator<<(std::ostream& _out, AssemblyItemsConstRef _i);
-inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _i) { return operator<<(_out, AssemblyItemsConstRef(&_i)); }
+inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _items)
+{
+	for (AssemblyItem const& item: _items)
+		_out << item;
+	return _out;
+}
 
 }
 }

test/libdevcrypto/AES.cpp

@@ -0,0 +1,92 @@
+/*
+	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/>.
+*/
+/** @file AES.cpp
+ * @author Christoph Jentzsch <cj@ethdev.com>
+ * @date 2015
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <libdevcore/Common.h>
+#include <libdevcrypto/Common.h>
+#include <libdevcore/SHA3.h>
+#include <libdevcrypto/AES.h>
+#include <libdevcore/FixedHash.h>
+
+using namespace std;
+using namespace dev;
+
+BOOST_AUTO_TEST_SUITE(AES)
+
+BOOST_AUTO_TEST_CASE(AesDecrypt)
+{
+	cout << "AesDecrypt" << endl;
+	bytes seed = fromHex("2dbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "test")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") == kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptWrongSeed)
+{
+	cout << "AesDecryptWrongSeed" << endl;
+	bytes seed = fromHex("badaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "test")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") != kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptWrongPassword)
+{
+	cout << "AesDecryptWrongPassword" << endl;
+	bytes seed = fromHex("2dbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "badtest")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") != kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeed)
+{
+	cout << "AesDecryptFailInvalidSeed" << endl;
+	bytes seed = fromHex("xdbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeedSize)
+{
+	cout << "AesDecryptFailInvalidSeedSize" << endl;
+	bytes seed = fromHex("000102030405060708090a0b0c0d0e0f");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeed2)
+{
+	cout << "AesDecryptFailInvalidSeed2" << endl;
+	bytes seed = fromHex("000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+BOOST_AUTO_TEST_CASE(AuthenticatedStreamConstructor)
+{
+	cout << "AuthenticatedStreamConstructor" << endl;
+
+	Secret const sec("test");
+	crypto::aes::AuthenticatedStream as(crypto::aes::Encrypt, sec, 0);
+	BOOST_CHECK(as.getMacInterval() == 0);
+	as.adjustInterval(1);
+	BOOST_CHECK(as.getMacInterval() == 1);
+	crypto::aes::AuthenticatedStream as_mac(crypto::aes::Encrypt, h128(), h128(), 42);
+	BOOST_CHECK(as_mac.getMacInterval() == 42);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+

test/libethereum/state.cpp

@@ -129,9 +129,9 @@ BOOST_AUTO_TEST_CASE(stPreCompiledContracts)
 	dev::test::executeTests("stPreCompiledContracts", "/StateTests",dev::test::getFolder(__FILE__) + "/StateTestsFiller", dev::test::doStateTests);
 }
 
-BOOST_AUTO_TEST_CASE(stPrecompiledContractsTransaction)
+BOOST_AUTO_TEST_CASE(stPreCompiledContractsTransaction)
 {
-	dev::test::executeTests("stPrecompiledContractsTransaction", "/StateTests",dev::test::getFolder(__FILE__) + "/StateTestsFiller", dev::test::doStateTests);
+	dev::test::executeTests("stPreCompiledContractsTransaction", "/StateTests",dev::test::getFolder(__FILE__) + "/StateTestsFiller", dev::test::doStateTests);
 }
 
 BOOST_AUTO_TEST_CASE(stLogTests)