Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #47 from pmconrad/testing

Browse source 
Testing
This commit is contained in:
Vikram Rajkumar 2015-07-29 13:29:22 -04:00
commit 088dadd124
23 changed files with 810 additions and 197 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
CMakeLists.txt
View file

@ -322,23 +322,23 @@ add_executable( api tests/api.cpp )
target_link_libraries( api fc )
if( ECC_IMPL STREQUAL secp256k1 )
add_executable( blind tests/blind.cpp )
add_executable( blind tests/all_tests.cpp tests/crypto/blind.cpp )
target_link_libraries( blind fc )
endif()
include_directories( vendor/websocketpp )
add_executable( ntp_test ntp_test.cpp )
add_executable( ntp_test tests/all_tests.cpp tests/network/ntp_test.cpp )
target_link_libraries( ntp_test fc )
add_executable( task_cancel_test tests/task_cancel.cpp )
add_executable( task_cancel_test tests/all_tests.cpp tests/thread/task_cancel.cpp )
target_link_libraries( task_cancel_test fc )
add_executable( bloom_test tests/bloom_test.cpp )
add_executable( bloom_test tests/all_tests.cpp tests/bloom_test.cpp )
target_link_libraries( bloom_test fc )
add_executable( real128_test tests/real128_test.cpp )
add_executable( real128_test tests/all_tests.cpp tests/real128_test.cpp )
target_link_libraries( real128_test fc )
@ -348,11 +348,9 @@ target_link_libraries( udt_server fc udt )
add_executable( udt_client tests/udtc.cpp )
target_link_libraries( udt_client fc udt )
add_executable( ecc_test tests/ecc_test.cpp )
add_executable( ecc_test tests/crypto/ecc_test.cpp )
target_link_libraries( ecc_test fc )
#add_executable( test_compress tests/compress.cpp )
#target_link_libraries( test_compress fc )
#add_executable( test_aes tests/aes_test.cpp )
#target_link_libraries( test_aes fc ${rt_library} ${pthread_library} )
#add_executable( test_sleep tests/sleep.cpp )
@ -360,6 +358,21 @@ target_link_libraries( ecc_test fc )
#add_executable( test_rate_limiting tests/rate_limiting.cpp )
#target_link_libraries( test_rate_limiting fc )
add_executable( all_tests tests/all_tests.cpp
tests/compress/compress.cpp
tests/crypto/aes_test.cpp
tests/crypto/base_n_tests.cpp
tests/crypto/bigint_test.cpp
tests/crypto/blind.cpp
tests/crypto/blowfish_test.cpp
tests/crypto/sha_tests.cpp
tests/network/ntp_test.cpp
tests/thread/task_cancel.cpp
tests/bloom_test.cpp
tests/real128_test.cpp
)
target_link_libraries( all_tests fc )
if(WIN32)
# add addtional import library on windows platform
target_link_libraries( fc PUBLIC crypt32.lib)

6
README-ecc.md
View file

@ -22,8 +22,8 @@ your system.
Testing
-------
Type "make ecc_test" to build the ecc_test executable from tests/ecc_test.cpp
with the currently configured ECC implementation.
Type "make ecc_test" to build the ecc_test executable from
tests/crypto/ecc_test.cpp with the currently configured ECC implementation.
ecc_test expects two arguments:
@ -38,6 +38,6 @@ If the file does exist, intermediate results from the current ECC backend
are compared with the file contents.
For a full round of interoperability testing, you can use the script
tests/ecc-interop.sh .
tests/crypto/ecc-interop.sh .
None of the test runs should produce any output.

28
ntp_test.cpp
View file

@ -1,28 +0,0 @@
#include <fc/network/ntp.hpp>
#include <fc/log/logger.hpp>
#include <fc/thread/thread.hpp>
int main( int argc, char** argv )
{
fc::ntp ntp_service;
ntp_service.set_request_interval(5);
fc::usleep(fc::seconds(4) );
auto time = ntp_service.get_time();
if( time )
{
auto ntp_time = *time;
auto delta = ntp_time - fc::time_point::now();
auto minutes = delta.count() / 1000000 / 60;
auto hours = delta.count() / 1000000 / 60 / 60;
auto seconds = delta.count() / 1000000;
auto msec= delta.count() / 1000;
idump( (fc::time_point::now() ) );
idump( (ntp_time)(delta)(msec)(seconds)(minutes)(hours) );
}
else
{
elog( "no response" );
}
return 0;
}

7
src/crypto/base32.cpp
View file

@ -7,16 +7,17 @@ namespace fc
{
auto len = cyoBase32DecodeGetLength( b32.size() );
std::vector<char> v(len);
cyoBase32Decode( v.data(), b32.c_str(), b32.size() );
len = cyoBase32Decode( v.data(), b32.c_str(), b32.size() );
v.resize( len );
return v;
}
std::string to_base32( const char* data, size_t len )
{
auto s = cyoBase16EncodeGetLength(len);
auto s = cyoBase32EncodeGetLength(len);
std::vector<char> b32;
b32.resize(s);
cyoBase16Encode( b32.data(), data, len );
cyoBase32Encode( b32.data(), data, len );
b32.resize( b32.size()-1); // strip the nullterm
return std::string(b32.begin(),b32.end());
}

47
src/crypto/base36.cpp
View file

@ -7,9 +7,20 @@ namespace fc
fc::string to_base36( const char* data, size_t len )
{
if( len == 0 ) return fc::string();
fc::bigint value( data, len );
const char* src = data;
int src_len = len;
char buffer[len+1];
if (*data & 0x80) {
buffer[0] = 0;
memcpy( buffer + 1, data, len );
src = buffer;
src_len++;
}
fc::bigint value( src, src_len );
auto base36 = "0123456789abcdefghijklmnopqrstuvwxyz";
std::vector<char> out( static_cast<size_t>(len * 1.6) + 1 );
std::vector<char> out( static_cast<size_t>(len * 1.6) + 2 );
int pos = out.size() - 1;
out[pos] = '\0';
fc::bigint _36(36);
@ -19,7 +30,9 @@ namespace fc
out[pos] = base36[(value % _36).to_int64()];
}
} while (value /= _36);
while (len-- > 0 && *data++ == 0) {
out[--pos] = '0';
}
return &out[pos]; //fc::string( &out[pos], out.size() - pos);
}
@ -30,21 +43,39 @@ namespace fc
std::vector<char> from_base36( const fc::string& b36 )
{
if ( b36.empty() ) {
std::vector<char> empty;
return empty;
}
fc::bigint value;
fc::bigint pos = 0;
fc::bigint _36(36);
for( auto itr = b36.begin(); itr != b36.end(); ++itr )
for( auto itr = b36.rbegin(); itr != b36.rend(); ++itr )
{
if( *itr - '0' < 10 ) value = value + _36.exp(pos) * fc::bigint(*itr - '0');
else if( *itr - 'a' < 26 ) value = value + (_36.exp(pos) * fc::bigint(10+*itr - 'a'));
else if( *itr - 'A' < 26 ) value = value + (_36.exp(pos) * fc::bigint(10+*itr - 'A'));
if( *itr >= '0' && *itr <= '9' )
value = value + _36.exp(pos) * fc::bigint(*itr - '0');
else if( *itr >= 'a' && *itr <= 'z' )
value = value + (_36.exp(pos) * fc::bigint(10+*itr - 'a'));
else if( *itr >= 'A' && *itr <= 'Z' )
value = value + (_36.exp(pos) * fc::bigint(10+*itr - 'A'));
else
{
wlog("unknown '${char}'", ("char",fc::string(&*itr,1)) );
}
++pos;
}
return value;
std::vector<char> bytes = value;
int leading_zeros = 0, len = bytes.size();
const char *in = b36.c_str();
while (*in++ == '0') { leading_zeros++; }
char* first = bytes.data();
while (len > 0 && *first == 0) { first++; len--; }
std::vector<char> result;
result.resize(leading_zeros + len, 0);
memcpy( result.data() + leading_zeros, first, len );
return result;
}
}

2
src/crypto/base58.cpp
View file

@ -631,7 +631,7 @@ size_t from_base58( const std::string& base58_str, char* out_data, size_t out_da
if( !DecodeBase58( base58_str.c_str(), out ) ) {
FC_THROW_EXCEPTION( parse_error_exception, "Unable to decode base58 string ${base58_str}", ("base58_str",base58_str) );
}
FC_ASSERT( out.size() <= out_data_len );
memcpy( out_data, out.data(), out.size() );
return out.size();
}

46
tests/aes_test.cpp
View file

@ -1,46 +0,0 @@
#include <iostream>
#include <fc/crypto/aes.hpp>
#include <fc/crypto/city.hpp>
#include <fc/exception/exception.hpp>
#include <fc/variant.hpp>
int main( int argc, char** )
{
std::string line;
std::getline( std::cin, line );
auto key = fc::sha512::hash( "hello", 5 );
while( std::cin && line != "q" )
{
try {
std::vector<char> data( line.c_str(),line.c_str()+line.size()+1 );
std::vector<char> crypt = fc::aes_encrypt( key, data );
std::vector<char> dcrypt = fc::aes_decrypt( key, crypt );
std::cout<<"line.size: '"<<line.size()<<"'\n";
std::cout<<"data.size: '"<<data.size()<<"'\n";
std::cout<<"crypt.size: '"<<crypt.size()<<"'\n";
std::cout<<"dcrypt.size: '"<<dcrypt.size()<<"'\n";
std::cout<<"line: '"<<line<<"'\n";
std::cout<<"dcrypt: '"<<dcrypt.data()<<"'\n";
std::cout<<"dcrypt: "<<fc::variant(dcrypt).as_string()<<"\n";
std::cout<<"crypt: "<<fc::variant(crypt).as_string()<<"\n";
memset( crypt.data(), 0, crypt.size() );
fc::aes_encoder enc;
enc.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
auto len = enc.encode( dcrypt.data(), dcrypt.size(), crypt.data() );
// enc.final_encode( crypt.data() + len );
std::cout<<"crypt: "<<fc::variant(crypt).as_string()<<"\n";
fc::aes_decoder dec;
dec.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
}
catch ( fc::exception& e )
{
std::cout<<e.to_detail_string()<<"\n";
}
std::getline( std::cin, line );
}
return 0;
}

3
tests/all_tests.cpp Normal file
View file

@ -0,0 +1,3 @@
#define BOOST_TEST_MODULE AllTests
#include <boost/test/unit_test.hpp>

83
tests/bloom_test.cpp
View file

@ -1,3 +1,5 @@
#include <boost/test/unit_test.hpp>
#include <fc/bloom_filter.hpp>
#include <fc/exception/exception.hpp>
#include <fc/reflect/variant.hpp>
@ -10,10 +12,8 @@
using namespace fc;
int main( int argc, char** argv )
static bloom_parameters setup_parameters()
{
try {
bloom_parameters parameters;
// How many elements roughly do we expect to insert?
@ -27,25 +27,31 @@ int main( int argc, char** argv )
if (!parameters)
{
std::cout << "Error - Invalid set of bloom filter parameters!" << std::endl;
return 1;
BOOST_FAIL( "Error - Invalid set of bloom filter parameters!" );
}
parameters.compute_optimal_parameters();
//Instantiate Bloom Filter
bloom_filter filter(parameters);
return parameters;
}
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(bloom_test_1)
{
try {
//Instantiate Bloom Filter
bloom_filter filter(setup_parameters());
if( argc > 1 )
{
uint32_t count = 0;
std::string line;
std::ifstream in(argv[1]);
std::ifstream in("README.md");
std::ofstream words("words.txt");
while( !in.eof() && count < 100000 )
{
std::getline(in, line);
std::cout << "'"<<line<<"'\n";
// std::cout << "'"<<line<<"'\n";
if( !filter.contains(line) )
{
filter.insert( line );
@ -53,23 +59,29 @@ int main( int argc, char** argv )
++count;
}
}
wdump((filter));
// wdump((filter));
auto packed_filter = fc::raw::pack(filter);
wdump((packed_filter.size()));
wdump((packed_filter));
std::ofstream out(argv[2]);
std::string str = fc::json::to_string(packed_filter);
// wdump((packed_filter.size()));
// wdump((packed_filter));
std::stringstream out;
// std::string str = fc::json::to_string(packed_filter);
auto b64 = fc::base64_encode( packed_filter.data(), packed_filter.size() );
for( uint32_t i = 0; i < b64.size(); i += 1024 )
out << '"' << b64.substr( i, 1024 ) << "\",\n";
return 0;
}
catch ( const fc::exception& e )
{
edump((e.to_detail_string()) );
}
}
BOOST_AUTO_TEST_CASE(bloom_test_2)
{
try {
//Instantiate Bloom Filter
bloom_filter filter(setup_parameters());
std::string str_list[] = { "AbC", "iJk", "XYZ" };
std::string str_list[] = { "AbC", "iJk", "XYZ" };
// Insert into Bloom Filter
{
@ -91,19 +103,13 @@ int main( int argc, char** argv )
// Query the existence of strings
for (std::size_t i = 0; i < (sizeof(str_list) / sizeof(std::string)); ++i)
{
if (filter.contains(str_list[i]))
{
std::cout << "BF contains: " << str_list[i] << std::endl;
}
BOOST_CHECK( filter.contains(str_list[i]) );
}
// Query the existence of numbers
for (std::size_t i = 0; i < 100; ++i)
{
if (filter.contains(i))
{
std::cout << "BF contains: " << i << std::endl;
}
BOOST_CHECK( filter.contains(i) );
}
std::string invalid_str_list[] = { "AbCX", "iJkX", "XYZX" };
@ -111,31 +117,20 @@ int main( int argc, char** argv )
// Query the existence of invalid strings
for (std::size_t i = 0; i < (sizeof(invalid_str_list) / sizeof(std::string)); ++i)
{
if (filter.contains(invalid_str_list[i]))
{
std::cout << "BF falsely contains: " << invalid_str_list[i] << std::endl;
}
BOOST_CHECK( !filter.contains(invalid_str_list[i]) );
}
// Query the existence of invalid numbers
for (int i = -1; i > -100; --i)
{
if (filter.contains(i))
{
std::cout << "BF falsely contains: " << i << std::endl;
}
BOOST_CHECK( !filter.contains(i) );
}
}
wdump((filter));
auto packed_filter = fc::raw::pack(filter);
wdump((packed_filter.size()));
wdump((packed_filter));
return 0;
}
catch ( const fc::exception& e )
{
edump((e.to_detail_string()) );
}
}
BOOST_AUTO_TEST_SUITE_END()

27
tests/compress.cpp
View file

@ -1,27 +0,0 @@
#include <iostream>
#include <fc/compress/smaz.hpp>
#include <fc/exception/exception.hpp>
int main( int argc, char** )
{
std::string line;
std::getline( std::cin, line );
while( std::cin && line != "q" )
{
try {
std::string compressed = fc::smaz_compress( line );
std::cout<<"compressed size: "<<compressed.size()<<"\n";
std::string decomp = fc::smaz_decompress( compressed );
std::cout<<"decomp: '"<<decomp<<"'\n";
std::cout<<"line: '"<<line<<"'\n";
FC_ASSERT( decomp == line );
}
catch ( fc::exception& e )
{
std::cout<<e.to_detail_string()<<"\n";
}
std::getline( std::cin, line );
}
return 0;
}

89
tests/compress/compress.cpp Normal file
View file

@ -0,0 +1,89 @@
#include <boost/test/unit_test.hpp>
#include <fstream>
#include <iostream>
#include <fc/compress/smaz.hpp>
#include <fc/compress/zlib.hpp>
#include <fc/exception/exception.hpp>
BOOST_AUTO_TEST_SUITE(compress)
BOOST_AUTO_TEST_CASE(smaz_test)
{
std::ifstream testfile;
testfile.open("README.md");
std::stringstream buffer;
std::string line;
std::getline( testfile, line );
while( testfile.good() )
{
buffer << line << "\n";
try {
std::string compressed = fc::smaz_compress( line );
std::string decomp = fc::smaz_decompress( compressed );
BOOST_CHECK_EQUAL( decomp, line );
}
catch ( fc::exception& e )
{
std::cout<<e.to_detail_string()<<"\n";
}
std::getline( testfile, line );
}
line = buffer.str();
std::string compressed = fc::smaz_compress( line );
std::string decomp = fc::smaz_decompress( compressed );
BOOST_CHECK_EQUAL( decomp, line );
}
extern "C" {
enum
{
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
TINFL_FLAG_HAS_MORE_INPUT = 2,
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
TINFL_FLAG_COMPUTE_ADLER32 = 8
};
extern char* tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
}
static std::string zlib_decompress( const std::string compressed )
{
size_t decomp_len;
char* decomp = tinfl_decompress_mem_to_heap( compressed.c_str(), compressed.length(), &decomp_len, TINFL_FLAG_PARSE_ZLIB_HEADER );
std::string result( decomp, decomp_len );
free( decomp );
return result;
}
BOOST_AUTO_TEST_CASE(zlib_test)
{
std::ifstream testfile;
testfile.open("README.md");
std::stringstream buffer;
std::string line;
std::getline( testfile, line );
while( testfile.good() )
{
buffer << line << "\n";
std::string compressed = fc::zlib_compress( line );
std::string decomp = zlib_decompress( compressed );
BOOST_CHECK_EQUAL( decomp, line );
std::getline( testfile, line );
}
line = buffer.str();
std::string compressed = fc::zlib_compress( line );
std::string decomp = zlib_decompress( compressed );
BOOST_CHECK_EQUAL( decomp, line );
}
BOOST_AUTO_TEST_SUITE_END()

70
tests/crypto/aes_test.cpp Normal file
View file

@ -0,0 +1,70 @@
#include <boost/test/unit_test.hpp>
#include <fstream>
#include <iostream>
#include <fc/crypto/aes.hpp>
#include <fc/crypto/city.hpp>
#include <fc/exception/exception.hpp>
#include <fc/variant.hpp>
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(aes_test)
{
std::ifstream testfile;
testfile.open("README.md");
auto key = fc::sha512::hash( "hello", 5 );
std::stringstream buffer;
std::string line;
std::getline( testfile, line );
while( testfile.good() )
{
// std::cout << line << "\n";
buffer << line << "\n";
try {
std::vector<char> data( line.c_str(),line.c_str()+line.size()+1 );
std::vector<char> crypt = fc::aes_encrypt( key, data );
std::vector<char> dcrypt = fc::aes_decrypt( key, crypt );
BOOST_CHECK( data == dcrypt );
// memset( crypt.data(), 0, crypt.size() );
// fc::aes_encoder enc;
// enc.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
// auto len = enc.encode( dcrypt.data(), dcrypt.size(), crypt.data() );
// BOOST_CHECK_EQUAL( dcrypt.size(), len );
//
// fc::aes_decoder dec;
// dec.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
// len = dec.decode( crypt.data(), len, dcrypt.data() );
// BOOST_CHECK_EQUAL( dcrypt.size(), len );
// BOOST_CHECK( !memcmp( dcrypt.data(), data.data(), len) );
}
catch ( fc::exception& e )
{
std::cout<<e.to_detail_string()<<"\n";
}
std::getline( testfile, line );
}
line = buffer.str();
std::vector<char> data( line.c_str(),line.c_str()+line.size()+1 );
std::vector<char> crypt = fc::aes_encrypt( key, data );
std::vector<char> dcrypt = fc::aes_decrypt( key, crypt );
BOOST_CHECK( data == dcrypt );
// memset( crypt.data(), 0, crypt.size() );
// fc::aes_encoder enc;
// enc.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
// auto len = enc.encode( dcrypt.data(), dcrypt.size(), crypt.data() );
// BOOST_CHECK_EQUAL( dcrypt.size(), len );
//
// fc::aes_decoder dec;
// dec.init( fc::sha256::hash((char*)&key,sizeof(key) ), fc::city_hash_crc_128( (char*)&key, sizeof(key) ) );
// len = dec.decode( crypt.data(), len, dcrypt.data() );
// BOOST_CHECK_EQUAL( dcrypt.size(), len );
// BOOST_CHECK( !memcmp( dcrypt.data(), data.data(), len) );
}
BOOST_AUTO_TEST_SUITE_END()

150
tests/crypto/base_n_tests.cpp Normal file
View file

@ -0,0 +1,150 @@
#include <boost/test/unit_test.hpp>
#include <fc/crypto/hex.hpp>
#include <fc/crypto/base32.hpp>
#include <fc/crypto/base36.hpp>
#include <fc/crypto/base58.hpp>
#include <fc/crypto/base64.hpp>
#include <fc/exception/exception.hpp>
#include <iostream>
static const std::string TEST1("");
static const std::string TEST2("\0\00101", 4);
static const std::string TEST3("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
static const std::string TEST4("\377\376\000\375\001\374", 6);
static const std::string TEST5("\0\0\0", 3);
static void test_16( const std::string& test, const std::string& expected )
{
std::vector<char> vec( test.begin(), test.end() );
fc::string enc1 = fc::to_hex( vec );
fc::string enc2 = fc::to_hex( test.c_str(), test.size() );
BOOST_CHECK_EQUAL( enc1, enc2 );
BOOST_CHECK_EQUAL( expected, enc2 );
char out[32];
int len = fc::from_hex( enc1, out, 32 );
BOOST_CHECK_EQUAL( test.size(), len );
BOOST_CHECK( !memcmp( test.c_str(), out, len ) );
if (len > 10) {
BOOST_CHECK( fc::from_hex( enc1, out, 10 ) <= 10 );
}
}
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(hex_test)
{
test_16( TEST1, "" );
test_16( TEST2, "00013031" );
test_16( TEST3, "4142434445464748494a4b4c4d4e4f505152535455565758595a" );
test_16( TEST4, "fffe00fd01fc" );
test_16( TEST5, "000000" );
}
static void test_32( const std::string& test, const std::string& expected )
{
std::vector<char> vec( test.begin(), test.end() );
fc::string enc1 = fc::to_base32( vec );
fc::string enc2 = fc::to_base32( test.c_str(), test.size() );
BOOST_CHECK_EQUAL( enc1, enc2 );
BOOST_CHECK_EQUAL( expected, enc2 );
std::vector<char> dec = fc::from_base32( enc1 );
BOOST_CHECK_EQUAL( vec.size(), dec.size() );
BOOST_CHECK( !memcmp( vec.data(), dec.data(), vec.size() ) );
}
BOOST_AUTO_TEST_CASE(base32_test)
{
test_32( TEST1, "" );
test_32( TEST2, "AAATAMI=" );
test_32( TEST3, "IFBEGRCFIZDUQSKKJNGE2TSPKBIVEU2UKVLFOWCZLI======" );
test_32( TEST4, "777AB7IB7Q======" );
test_32( TEST5, "AAAAA===" );
}
static void test_36( const std::string& test, const std::string& expected )
{
std::vector<char> vec( test.begin(), test.end() );
fc::string enc1 = fc::to_base36( vec );
fc::string enc2 = fc::to_base36( test.c_str(), test.size() );
BOOST_CHECK_EQUAL( enc1, enc2 );
BOOST_CHECK_EQUAL( expected, enc2 );
std::vector<char> dec = fc::from_base36( enc1 );
BOOST_CHECK_EQUAL( vec.size(), dec.size() );
BOOST_CHECK( !memcmp( vec.data(), dec.data(), vec.size() ) );
}
BOOST_AUTO_TEST_CASE(base36_test)
{
test_36( TEST1, "" );
test_36( TEST2, "01o35" );
test_36( TEST3, "l4ksdleyi5pnl0un5raue268ptj43dwjwmz15ie2" );
test_36( TEST4, "2rrrvpb7y4" );
test_36( TEST5, "000" );
}
static void test_58( const std::string& test, const std::string& expected )
{
std::vector<char> vec( test.begin(), test.end() );
fc::string enc1 = fc::to_base58( vec );
fc::string enc2 = fc::to_base58( test.c_str(), test.size() );
BOOST_CHECK_EQUAL( enc1, enc2 );
BOOST_CHECK_EQUAL( expected, enc2 );
std::vector<char> dec = fc::from_base58( enc1 );
BOOST_CHECK_EQUAL( vec.size(), dec.size() );
BOOST_CHECK( !memcmp( vec.data(), dec.data(), vec.size() ) );
char buffer[64];
size_t len = fc::from_base58( enc1, buffer, 64 );
BOOST_CHECK( len <= 64 );
BOOST_CHECK( !memcmp( vec.data(), buffer, len ) );
if ( len > 10 ) {
try {
len = fc::from_base58( enc1, buffer, 10 );
BOOST_CHECK( len <= 10 );
} catch ( fc::exception expected ) {}
}
}
BOOST_AUTO_TEST_CASE(base58_test)
{
test_58( TEST1, "" );
test_58( TEST2, "1Q9e" );
test_58( TEST3, "2zuFXTJSTRK6ESktqhM2QDBkCnH1U46CnxaD" );
test_58( TEST4, "3CUeREErf" );
test_58( TEST5, "111" );
}
static void test_64( const std::string& test, const std::string& expected )
{
fc::string enc1 = fc::base64_encode( test );
fc::string enc2 = fc::base64_encode( test.c_str(), test.size() );
BOOST_CHECK_EQUAL( enc1, enc2 );
BOOST_CHECK_EQUAL( expected, enc2 );
std::string dec = fc::base64_decode( enc1 );
BOOST_CHECK_EQUAL( test.size(), dec.size() );
BOOST_CHECK_EQUAL( test, dec );
}
BOOST_AUTO_TEST_CASE(base64_test)
{
test_64( TEST1, "" );
test_64( TEST2, "AAEwMQ==" );
test_64( TEST3, "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo=" );
test_64( TEST4, "//4A/QH8" );
test_64( TEST5, "AAAA" );
}
BOOST_AUTO_TEST_SUITE_END()

77
tests/crypto/bigint_test.cpp Normal file
View file

@ -0,0 +1,77 @@
#include <boost/test/unit_test.hpp>
#include <fc/variant.hpp>
#include <fc/crypto/bigint.hpp>
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(bigint_test_1)
{
int64_t counter = 0, accu = 0, c_sq;
fc::bigint bi_accu(accu);
do {
c_sq = counter * counter;
fc::bigint add(c_sq);
bi_accu += add;
accu += c_sq;
BOOST_CHECK( fc::bigint(accu) == bi_accu );
bi_accu = bi_accu + add;
accu = accu + c_sq;
BOOST_CHECK_EQUAL( accu, bi_accu.to_int64() );
bi_accu = fc::bigint( bi_accu.dup() );
counter++;
} while (c_sq < 1000000);
fc::variant test;
fc::to_variant( bi_accu, test );
fc::bigint other;
fc::from_variant( test, other );
BOOST_CHECK( other == bi_accu );
}
BOOST_AUTO_TEST_CASE(bigint_test_2)
{
const fc::bigint bi_1(1), bi_3(3), bi_17(17), bi_65537(65537);
fc::bigint bi_accu(bi_1);
do {
std::vector<char> bytes = bi_accu;
fc::bigint a_1( bytes );
a_1 = a_1 + bi_1;
BOOST_CHECK( bi_accu < a_1 );
bi_accu = a_1 * bi_accu;
BOOST_CHECK( bi_accu >= a_1 );
} while ( bi_accu.log2() <= 128 );
bi_accu = bi_accu;
BOOST_CHECK( bi_accu && !bi_accu.is_negative() && bi_accu != bi_1 );
BOOST_CHECK( bi_3.exp( bi_accu.log2() ) > bi_accu );
fc::bigint big(1);
big <<= 30; big += bi_17; big <<= 30; big++;
big <<= 30; big -= bi_17; big >>= 5; big--;
fc::bigint rest = bi_accu % big;
BOOST_CHECK( (bi_accu - rest) / big == bi_accu / big );
fc::bigint big2; big2 = big;
big2 *= bi_65537.exp(3);
big2 /= bi_65537.exp(3);
BOOST_CHECK( big2 == big );
big--;
BOOST_CHECK_EQUAL( (std::string) bi_1, "1" );
BOOST_CHECK_EQUAL( (std::string) bi_3, "3" );
BOOST_CHECK_EQUAL( (std::string) bi_17, "17" );
BOOST_CHECK_EQUAL( (std::string) bi_65537, "65537" );
BOOST_CHECK_EQUAL( (std::string) bi_65537.exp(3), "281487861809153" );
BOOST_CHECK_EQUAL( (std::string) bi_accu, "12864938683278671740537145998360961546653259485195806" );
BOOST_CHECK_EQUAL( (std::string) big, "38685626840157682946539517" );
}
BOOST_AUTO_TEST_SUITE_END()

51
tests/blind.cpp → tests/crypto/blind.cpp
View file

@ -1,16 +1,14 @@
#include <boost/test/unit_test.hpp>
#include <fc/crypto/elliptic.hpp>
#include <fc/log/logger.hpp>
#include <fc/io/raw.hpp>
#include <fc/variant.hpp>
#include <fc/reflect/variant.hpp>
//extern "C" {
//#include <secp256k1.h>
//}
//struct secp256k1_scalar_t { uint64_t v[4]; };
//extern "C" { void secp256k1_scalar_get_b32(unsigned char *bin, const struct secp256k1_scalar_t* a); }
BOOST_AUTO_TEST_SUITE(fc_crypto)
int main( int argc, char** argv )
BOOST_AUTO_TEST_CASE(blind_test)
{
try {
auto InB1 = fc::sha256::hash("InB1");
@ -34,16 +32,16 @@ int main( int argc, char** argv )
//FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {OutC1}, -60 ) );
FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {OutC1,OutC2}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {InC1,InC2}, {OutC1,OutC2}, 0 ) );
auto nonce = fc::sha256::hash("nonce");
auto proof = fc::ecc::range_proof_sign( 0, OutC1, OutB1, nonce, 0, 0, 40 );
wdump( (proof.size()));
// wdump( (proof.size()));
auto result = fc::ecc::range_get_info( proof );
wdump((result));
FC_ASSERT( result.max_value >= 60 );
FC_ASSERT( result.min_value >= 0 );
// wdump((result));
BOOST_CHECK( result.max_value >= 60 );
BOOST_CHECK( result.min_value >= 0 );
auto B1 = fc::sha256::hash("B1");
@ -62,10 +60,10 @@ int main( int argc, char** argv )
auto B2m1 = fc::ecc::blind_sum( {B2,B1}, 1 );
auto C2m1 = fc::ecc::blind( B2m1, 1 );
FC_ASSERT( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
{
@ -82,13 +80,13 @@ int main( int argc, char** argv )
auto C3 = fc::ecc::blind( B1, 1 );
auto C4 = fc::ecc::blind( B1, 2 );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C3}, -1 ) );
FC_ASSERT( fc::ecc::verify_sum( {C1}, {C1}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C2}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C2}, 1 ) );
FC_ASSERT( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
FC_ASSERT( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C1}, -INT64_MAX ) );
BOOST_CHECK( fc::ecc::verify_sum( {C2}, {C3}, -1 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C1}, {C1}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C2}, {C2}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C3}, {C2}, 1 ) );
BOOST_CHECK( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
BOOST_CHECK( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
BOOST_CHECK( fc::ecc::verify_sum( {C2}, {C1}, -INT64_MAX ) );
}
@ -101,16 +99,15 @@ int main( int argc, char** argv )
auto InC = fc::ecc::blind( InBlind, 1000 );
auto In0 = fc::ecc::blind( InBlind, 0 );
FC_ASSERT( fc::ecc::verify_sum( {InC}, {OutC1,OutC2}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {InC}, {In0}, 1000 ) );
BOOST_CHECK( fc::ecc::verify_sum( {InC}, {OutC1,OutC2}, 0 ) );
BOOST_CHECK( fc::ecc::verify_sum( {InC}, {In0}, 1000 ) );
}
}
catch ( const fc::exception& e )
{
edump((e.to_detail_string()));
}
return 0;
}
BOOST_AUTO_TEST_SUITE_END()

169
tests/crypto/blowfish_test.cpp Normal file
View file

@ -0,0 +1,169 @@
#include <boost/test/unit_test.hpp>
#include <fc/crypto/blowfish.hpp>
#include <fc/crypto/hex.hpp>
// Test vectors from https://www.schneier.com/code/vectors.txt
struct ecb_testdata {
char key[17], plain[17], cipher[17];
} ecb_tests[] = {
{ "0000000000000000", "0000000000000000", "4EF997456198DD78" },
{ "FFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFF", "51866FD5B85ECB8A" },
{ "3000000000000000", "1000000000000001", "7D856F9A613063F2" },
{ "1111111111111111", "1111111111111111", "2466DD878B963C9D" },
{ "0123456789ABCDEF", "1111111111111111", "61F9C3802281B096" },
{ "1111111111111111", "0123456789ABCDEF", "7D0CC630AFDA1EC7" },
{ "0000000000000000", "0000000000000000", "4EF997456198DD78" },
{ "FEDCBA9876543210", "0123456789ABCDEF", "0ACEAB0FC6A0A28D" },
{ "7CA110454A1A6E57", "01A1D6D039776742", "59C68245EB05282B" },
{ "0131D9619DC1376E", "5CD54CA83DEF57DA", "B1B8CC0B250F09A0" },
{ "07A1133E4A0B2686", "0248D43806F67172", "1730E5778BEA1DA4" },
{ "3849674C2602319E", "51454B582DDF440A", "A25E7856CF2651EB" },
{ "04B915BA43FEB5B6", "42FD443059577FA2", "353882B109CE8F1A" },
{ "0113B970FD34F2CE", "059B5E0851CF143A", "48F4D0884C379918" },
{ "0170F175468FB5E6", "0756D8E0774761D2", "432193B78951FC98" },
{ "43297FAD38E373FE", "762514B829BF486A", "13F04154D69D1AE5" },
{ "07A7137045DA2A16", "3BDD119049372802", "2EEDDA93FFD39C79" },
{ "04689104C2FD3B2F", "26955F6835AF609A", "D887E0393C2DA6E3" },
{ "37D06BB516CB7546", "164D5E404F275232", "5F99D04F5B163969" },
{ "1F08260D1AC2465E", "6B056E18759F5CCA", "4A057A3B24D3977B" },
{ "584023641ABA6176", "004BD6EF09176062", "452031C1E4FADA8E" },
{ "025816164629B007", "480D39006EE762F2", "7555AE39F59B87BD" },
{ "49793EBC79B3258F", "437540C8698F3CFA", "53C55F9CB49FC019" },
{ "4FB05E1515AB73A7", "072D43A077075292", "7A8E7BFA937E89A3" },
{ "49E95D6D4CA229BF", "02FE55778117F12A", "CF9C5D7A4986ADB5" },
{ "018310DC409B26D6", "1D9D5C5018F728C2", "D1ABB290658BC778" },
{ "1C587F1C13924FEF", "305532286D6F295A", "55CB3774D13EF201" },
{ "0101010101010101", "0123456789ABCDEF", "FA34EC4847B268B2" },
{ "1F1F1F1F0E0E0E0E", "0123456789ABCDEF", "A790795108EA3CAE" },
{ "E0FEE0FEF1FEF1FE", "0123456789ABCDEF", "C39E072D9FAC631D" },
{ "0000000000000000", "FFFFFFFFFFFFFFFF", "014933E0CDAFF6E4" },
{ "FFFFFFFFFFFFFFFF", "0000000000000000", "F21E9A77B71C49BC" },
{ "0123456789ABCDEF", "0000000000000000", "245946885754369A" },
{ "FEDCBA9876543210", "FFFFFFFFFFFFFFFF", "6B5C5A9C5D9E0A5A" }
};
const std::string key_test_key = "F0E1D2C3B4A5968778695A4B3C2D1E0F0011223344556677";
const std::string key_test_plain = "FEDCBA9876543210";
const char key_test_ciphers[][17] = {
"F9AD597C49DB005E",
"E91D21C1D961A6D6",
"E9C2B70A1BC65CF3",
"BE1E639408640F05",
"B39E44481BDB1E6E",
"9457AA83B1928C0D",
"8BB77032F960629D",
"E87A244E2CC85E82",
"15750E7A4F4EC577",
"122BA70B3AB64AE0",
"3A833C9AFFC537F6",
"9409DA87A90F6BF2",
"884F80625060B8B4",
"1F85031C19E11968",
"79D9373A714CA34F",
"93142887EE3BE15C",
"03429E838CE2D14B",
"A4299E27469FF67B",
"AFD5AED1C1BC96A8",
"10851C0E3858DA9F",
"E6F51ED79B9DB21F",
"64A6E14AFD36B46F",
"80C7D7D45A5479AD",
"05044B62FA52D080",
};
const std::string chain_test_key = "0123456789ABCDEFF0E1D2C3B4A59687";
const std::string chain_test_iv = "FEDCBA9876543210";
const std::string chain_test_plain = "7654321 Now is the time for \0\0\0\0";
const std::string chain_test_cbc = "6B77B4D63006DEE605B156E27403979358DEB9E7154616D959F1652BD5FF92CC";
const std::string chain_test_cfb = "E73214A2822139CAF26ECF6D2EB9E76E3DA3DE04D1517200519D57A6C3";
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(blowfish_ecb_test)
{
for ( int i = 0; i < 34; i++ ) {
unsigned char key[8], plain[8], cipher[8], out[8];
BOOST_CHECK_EQUAL( 8, fc::from_hex( ecb_tests[i].key, (char*) key, sizeof(key) ) );
BOOST_CHECK_EQUAL( 8, fc::from_hex( ecb_tests[i].plain, (char*) plain, sizeof(plain) ) );
BOOST_CHECK_EQUAL( 8, fc::from_hex( ecb_tests[i].cipher, (char*) cipher, sizeof(cipher) ) );
fc::blowfish fish;
fish.start( key, 8 );
fish.encrypt( plain, out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( cipher, out, 8) );
fish.decrypt( out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( plain, out, 8) );
fish.decrypt( cipher, out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( plain, out, 8) );
fish.encrypt( out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( cipher, out, 8) );
}
}
BOOST_AUTO_TEST_CASE(blowfish_key_test)
{
unsigned char key[24], plain[8], cipher[8], out[8];
BOOST_CHECK_EQUAL( 24, fc::from_hex( key_test_key.c_str(), (char*) key, sizeof(key) ) );
BOOST_CHECK_EQUAL( 8, fc::from_hex( key_test_plain.c_str(), (char*) plain, sizeof(plain) ) );
for ( unsigned int i = 0; i < sizeof(key); i++ ) {
BOOST_CHECK_EQUAL( 8, fc::from_hex( key_test_ciphers[i], (char*) cipher, sizeof(cipher) ) );
fc::blowfish fish;
fish.start( key, i + 1 );
fish.encrypt( plain, out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( cipher, out, 8) );
fish.decrypt( out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( plain, out, 8) );
fish.decrypt( cipher, out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( plain, out, 8) );
fish.encrypt( out, 8, fc::blowfish::ECB );
BOOST_CHECK( !memcmp( cipher, out, 8) );
}
}
static unsigned int from_bytes( const unsigned char* p ) {
return (((unsigned int) p[0]) << 24)
| (((unsigned int) p[1]) << 16)
| (((unsigned int) p[2]) << 8)
| ((unsigned int) p[3]);
}
BOOST_AUTO_TEST_CASE(blowfish_chain_test)
{
unsigned char key[16], iv[8], cipher[32], out[32];
BOOST_CHECK_EQUAL( 16, fc::from_hex( chain_test_key.c_str(), (char*) key, sizeof(key) ) );
BOOST_CHECK_EQUAL( 8, fc::from_hex( chain_test_iv.c_str(), (char*) iv, sizeof(iv) ) );
BOOST_CHECK_EQUAL( 32, fc::from_hex( chain_test_cbc.c_str(), (char*) cipher, sizeof(cipher) ) );
fc::blowfish fish;
fish.start( key, sizeof(key), fc::sblock( from_bytes( iv ), from_bytes( iv + 4 ) ) );
fish.encrypt( (unsigned char*) chain_test_plain.c_str(), out, sizeof(out), fc::blowfish::CBC );
BOOST_CHECK( !memcmp( cipher, out, sizeof(cipher) ) );
fish.reset_chain();
fish.decrypt( out, sizeof(out), fc::blowfish::CBC );
BOOST_CHECK( !memcmp( chain_test_plain.c_str(), out, 29 ) );
fish.reset_chain();
fish.encrypt( out, sizeof(out), fc::blowfish::CBC );
BOOST_CHECK( !memcmp( cipher, out, sizeof(cipher) ) );
fish.reset_chain();
fish.decrypt( cipher, out, sizeof(cipher), fc::blowfish::CBC );
BOOST_CHECK( !memcmp( chain_test_plain.c_str(), out, 29 ) );
BOOST_CHECK_EQUAL( 29, fc::from_hex( chain_test_cfb.c_str(), (char*) cipher, sizeof(cipher) ) );
fish.reset_chain();
fish.encrypt( (unsigned char*) chain_test_plain.c_str(), out, sizeof(out), fc::blowfish::CFB );
BOOST_CHECK( !memcmp( cipher, out, 29 ) );
fish.reset_chain(); memset( out + 29, 0, 3 );
fish.decrypt( out, sizeof(out), fc::blowfish::CFB );
BOOST_CHECK( !memcmp( chain_test_plain.c_str(), out, 29 ) );
fish.reset_chain(); memset( out + 29, 0, 3 );
fish.encrypt( out, sizeof(out), fc::blowfish::CFB );
BOOST_CHECK( !memcmp( cipher, out, 29 ) );
fish.reset_chain(); memset( out + 29, 0, 3 );
fish.decrypt( cipher, out, sizeof(cipher), fc::blowfish::CFB );
BOOST_CHECK( !memcmp( chain_test_plain.c_str(), out, 29 ) );
}
BOOST_AUTO_TEST_SUITE_END()

0
tests/ecc-interop.sh → tests/crypto/ecc-interop.sh
View file

0
tests/ecc_test.cpp → tests/crypto/ecc_test.cpp
View file

88
tests/crypto/sha_tests.cpp Normal file
View file

@ -0,0 +1,88 @@
#include <boost/test/unit_test.hpp>
#include <fc/crypto/sha1.hpp>
#include <fc/crypto/sha224.hpp>
#include <fc/crypto/sha256.hpp>
#include <fc/crypto/sha512.hpp>
#include <fc/exception/exception.hpp>
#include <iostream>
// SHA test vectors taken from http://www.di-mgt.com.au/sha_testvectors.html
static const std::string TEST1("abc");
static const std::string TEST2("");
static const std::string TEST3("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
static const std::string TEST4("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
static char TEST5[1000001];
static void init_5() {
memset( TEST5, 'a', sizeof(TEST5) - 1 );
TEST5[1000000] = 0;
}
template<typename H>
void test( const char* to_hash, const std::string& expected ) {
H hash = H::hash( to_hash, strlen( to_hash ) );
BOOST_CHECK_EQUAL( expected, (std::string) hash );
H hash2( expected );
BOOST_CHECK( hash == hash2 );
}
template<typename H>
void test( const std::string& to_hash, const std::string& expected ) {
test<H>( to_hash.c_str(), expected );
}
template void test<fc::sha1>( const std::string& test, const std::string& expected );
template void test<fc::sha224>( const std::string& test, const std::string& expected );
template void test<fc::sha256>( const std::string& test, const std::string& expected );
template void test<fc::sha512>( const std::string& test, const std::string& expected );
BOOST_AUTO_TEST_SUITE(fc_crypto)
BOOST_AUTO_TEST_CASE(sha1_test)
{
init_5();
test<fc::sha1>( TEST1, "a9993e364706816aba3e25717850c26c9cd0d89d" );
test<fc::sha1>( TEST2, "da39a3ee5e6b4b0d3255bfef95601890afd80709" );
test<fc::sha1>( TEST3, "84983e441c3bd26ebaae4aa1f95129e5e54670f1" );
test<fc::sha1>( TEST4, "a49b2446a02c645bf419f995b67091253a04a259" );
test<fc::sha1>( TEST5, "34aa973cd4c4daa4f61eeb2bdbad27316534016f" );
}
BOOST_AUTO_TEST_CASE(sha224_test)
{
init_5();
test<fc::sha224>( TEST1, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7" );
test<fc::sha224>( TEST2, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" );
test<fc::sha224>( TEST3, "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525" );
test<fc::sha224>( TEST4, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3" );
test<fc::sha224>( TEST5, "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67" );
}
BOOST_AUTO_TEST_CASE(sha256_test)
{
init_5();
test<fc::sha256>( TEST1, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" );
test<fc::sha256>( TEST2, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" );
test<fc::sha256>( TEST3, "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" );
test<fc::sha256>( TEST4, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1" );
test<fc::sha256>( TEST5, "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" );
}
BOOST_AUTO_TEST_CASE(sha512_test)
{
init_5();
test<fc::sha512>( TEST1, "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
"2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" );
test<fc::sha512>( TEST2, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"
"47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" );
test<fc::sha512>( TEST3, "204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335"
"96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445" );
test<fc::sha512>( TEST4, "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"
"501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" );
test<fc::sha512>( TEST5, "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb"
"de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" );
}
BOOST_AUTO_TEST_SUITE_END()

BIN
tests/ecc_test.interop.data
View file

Binary file not shown.

25
tests/network/ntp_test.cpp Normal file
View file

@ -0,0 +1,25 @@
#include <boost/test/unit_test.hpp>
#include <fc/network/ntp.hpp>
#include <fc/log/logger.hpp>
#include <fc/thread/thread.hpp>
BOOST_AUTO_TEST_SUITE(fc_network)
BOOST_AUTO_TEST_CASE( ntp_test )
{
fc::ntp ntp_service;
ntp_service.set_request_interval(5);
fc::usleep(fc::seconds(4) );
auto time = ntp_service.get_time();
BOOST_CHECK( time );
auto ntp_time = *time;
auto delta = ntp_time - fc::time_point::now();
// auto minutes = delta.count() / 1000000 / 60;
// auto hours = delta.count() / 1000000 / 60 / 60;
// auto seconds = delta.count() / 1000000;
auto msec= delta.count() / 1000;
BOOST_CHECK( msec < 100 );
}
BOOST_AUTO_TEST_SUITE_END()

5
tests/real128_test.cpp
View file

@ -1,8 +1,9 @@
#include <fc/real128.hpp>
#define BOOST_TEST_MODULE Real128Test
#include <boost/test/unit_test.hpp>
#include <fc/log/logger.hpp>
BOOST_AUTO_TEST_SUITE(fc)
using fc::real128;
using std::string;
@ -50,3 +51,5 @@ BOOST_AUTO_TEST_CASE(real128_test)
wdump((real128("12345.6789")) );
wdump( (ten/3*3) );
}
BOOST_AUTO_TEST_SUITE_END()

5
tests/task_cancel.cpp → tests/thread/task_cancel.cpp
View file

@ -1,4 +1,3 @@
#define BOOST_TEST_MODULE fc_task_cancel_tests
#include <boost/test/unit_test.hpp>
#include <fc/thread/thread.hpp>
@ -8,6 +7,8 @@
#include <fc/exception/exception.hpp>
#include <fc/thread/non_preemptable_scope_check.hpp>
BOOST_AUTO_TEST_SUITE(fc_thread)
BOOST_AUTO_TEST_CASE( leave_mutex_locked )
{
{
@ -239,3 +240,5 @@ BOOST_AUTO_TEST_CASE( cancel_scheduled_task )
}
BOOST_CHECK_EQUAL(task_execute_count, 2);
}
BOOST_AUTO_TEST_SUITE_END()