void CDatabaseOdbcMsSqlTest::TestCase_DestroyDatabase()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_DestroyDatabase ****" );
#if defined( _WIN32 )
UninstallSourceOdbcMsSql( DB_DATABASE );
UninstallDatabaseMsSql( DB_DATABASE, DB_USER, DB_PASS );
#endif
{
auto const guard = make_block_guard( [this]()
{
DoLoadPlugins();
}, []()
{
UnloadPlugins();
} );
std::unique_ptr< CDatabase > database( InstantiateDatabase( _type ) );
if ( database )
{
DatabaseConnectionSPtr connection = CreateConnection( *database, _server, _user, _password );
try
{
connection->ExecuteUpdate( QUERY_DROP_TABLE );
}
catch ( std::exception & )
{
BOOST_CHECK( false );
}
database->RemoveConnection();
}
}
CLogger::LogInfo( StringStream() << "**** End TestCase_DestroyDatabase ****" );
}
void CDatabaseOdbcMsSqlTest::TestCase_CreateDatabase()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_CreateDatabase ****" );
#if defined( _WIN32 )
InstallDatabaseMsSql( DB_DATABASE, DB_USER, DB_PASS );
InstallSourceOdbcMsSql( DB_DATABASE );
#endif
{
auto const guard = make_block_guard( [this]()
{
DoLoadPlugins();
}, []()
{
UnloadPlugins();
} );
std::unique_ptr< CDatabase > database( InstantiateDatabase( _type ) );
if ( database )
{
DatabaseConnectionSPtr connection = CreateConnection( *database, _server, _user, _password );
if ( connection && connection->IsConnected() )
{
connection->SelectDatabase( _database );
connection->ExecuteUpdate( _createTable );
}
}
}
CLogger::LogInfo( StringStream() << "**** End TestCase_CreateDatabase ****" );
}
EErrorType CDatabaseStatementOdbc::DoPreExecute()
{
EErrorType eResult = EErrorType_NONE;
if ( eResult == EErrorType_NONE )
{
SQLRETURN retCode = SQLExecute( _statementHandle );
if ( retCode == SQL_NEED_DATA )
{
SQLPOINTER pAddress;
std::map< const void *, CDatabaseParameter const * >::iterator it;
while ( ( retCode = SQLParamData( _statementHandle, &pAddress ) == SQL_NEED_DATA ) && eResult == EErrorType_NONE )
{
it = _mapParamsByPointer.find( pAddress );
if ( it != _mapParamsByPointer.end() )
{
eResult = static_cast< CDatabaseStatementParameterOdbc const * >( it->second )->GetBinding().PutData();
}
else
{
CLogger::LogError( ERROR_ODBC_STATEMENT_UNKNOWN_POINTER );
}
}
}
SqlSuccess( retCode, SQL_HANDLE_STMT, _statementHandle, StringStream() << INFO_ODBC_EXECUTE_STATEMENT << this );
}
return eResult;
}
EErrorType CDatabaseConnectionMySql::DoConnect( String & connectionString )
{
EErrorType ret = EErrorType_NONE;
try
{
_connection = mysql_init( NULL );
if ( !_connection )
{
DB_EXCEPT( EDatabaseExceptionCodes_ConnectionError, ERROR_MYSQL_CONNECTION );
}
uint32_t timeout = 180;
if ( mysql_options( _connection, MYSQL_OPT_CONNECT_TIMEOUT, &timeout ) )
{
CLogger::LogWarning( WARNING_MYSQL_UNKNOWN_OPTION + WARNING_MYSQL_OPT_CONNECT_TIMEOUT );
}
if ( !mysql_real_connect( _connection,
_server.c_str(),
_userName.c_str(),
_password.c_str(),
NULL,
0,
NULL,
CLIENT_REMEMBER_OPTIONS | CLIENT_MULTI_RESULTS ) )
{
StringStream error( ERROR_MYSQL_CONNECT );
error << mysql_error( _connection );
DB_EXCEPT( EDatabaseExceptionCodes_ConnectionError, error.str() );
}
MySQLCheck( mysql_set_character_set( _connection, MYSQL_OPTION_UTF8 ), INFO_MYSQL_SETTING_CHARSET, EDatabaseExceptionCodes_ConnectionError, _connection );
CLogger::LogDebug( StringStream() << DEBUG_MYSQL_CONNECTED );
CLogger::LogDebug( StringStream() << DEBUG_MYSQL_CLIENT_VERSION << mysql_get_client_info() );
CLogger::LogDebug( StringStream() << DEBUG_MYSQL_SERVER_HOST << mysql_get_host_info( _connection ) );
CLogger::LogDebug( StringStream() << DEBUG_MYSQL_SERVER_VERSION << mysql_get_server_info( _connection ) );
DoSetConnected( true );
}
COMMON_CATCH( ERROR_MYSQL_CONNECTION )
return ret;
}
void CDatabaseFixedPointTest::TestCase_FixedPointOutOfRange()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointOutOfRange ****" );
BOOST_CHECK_EQUAL( CFixedPoint::Get10Pow256( 0 ), int256_t( 1 ) );
BOOST_CHECK_EQUAL( CFixedPoint::Get10Pow256( 5 ), int256_t( 100000 ) );
BOOST_CHECK_EQUAL( CFixedPoint::Get10Pow256( 10 ), int256_t( 10000000000 ) );
BOOST_CHECK_EQUAL( CFixedPoint::Get10Pow256( 15 ), int256_t( 1000000000000000 ) );
CLogger::LogInfo( StringStream() << " Invalid Precision inferior to min" );
BOOST_CHECK_THROW( CFixedPoint( 0, CFixedPoint::GetMinPrecision() - 1, 0 ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Invalid Precision superior to max" );
BOOST_CHECK_THROW( CFixedPoint( 0, CFixedPoint::GetMaxPrecision() + 1, 0 ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Invalid dDecimals equal to precision" );
BOOST_CHECK_THROW( CFixedPoint( 0, CFixedPoint::GetMaxPrecision() / 2, CFixedPoint::GetMaxPrecision() / 2 ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Invalid Decimals superior to precision" );
BOOST_CHECK_THROW( CFixedPoint( 0, CFixedPoint::GetMaxPrecision() / 2, 1 + CFixedPoint::GetMaxPrecision() / 2 ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Min Precision: " << int( CFixedPoint::GetMinPrecision() ) );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointOutOfRange ****" );
}
void Pdb::DropWatch(PasteClip& clip)
{
String s = StringStream(GetString(clip)).GetLine();
if(s.GetCount()) {
watches.Add(s);
clip.SetAction(DND_COPY);
Data();
}
}
std::basic_string< wchar_t > str_convert< wchar_t, char >( std::basic_string< char > const & src )
{
std::basic_string< wchar_t > dst;
if ( !src.empty() )
{
try
{
std::unique_lock< std::mutex > lock( g_conversionMutex );
char * szloc = setlocale( LC_CTYPE, "" );
mbtowc( NULL, NULL, 0 );
size_t max = src.size();
int length = 1;
const char * in = src.c_str();
dst.reserve( src.size() );
while ( max > 0 && length >= 1 )
{
wchar_t wc;
length = mbtowc( &wc, in, max );
if ( length >= 1 )
{
dst += wc;
max -= length;
in += length;
}
}
setlocale( LC_CTYPE, szloc );
}
catch ( std::exception & exc )
{
CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << exc.what() );
}
catch ( ... )
{
CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << INFO_UNKNOWN );
}
}
return std::move( dst );
}
void CDatabaseFixedPointTest::TestCase_FixedPointDivision()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointDivision ****" );
CFixedPoint a, b, c;
CLogger::LogInfo( StringStream() << " No error, same precision" );
a = CFixedPoint( 996, 3, 0 );
b = CFixedPoint( 3, 3, 0 );
BOOST_CHECK_EQUAL( a / b, CFixedPoint( 332, 3, 0 ) );
CLogger::LogInfo( StringStream() << " Division by zero" );
c = CFixedPoint( 0, 1, 0 );
BOOST_CHECK_THROW( b / c, CDatabaseException );
CLogger::LogInfo( StringStream() << " Different precisions" );
b = CFixedPoint( 55, 5, 2 );
a = CFixedPoint( 334, 3, 1 );
BOOST_CHECK_EQUAL( a / b, CFixedPoint( 60, 3, 1 ) );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointDivision ****" );
}
void CDatabaseFixedPointTest::TestCase_FixedPointMaxPrecisionMinDecimals()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointMaxPrecisionMinDecimals ****" );
int precision = CFixedPoint::GetMaxPrecision();
int decimals = 0;
int64_t value;
CLogger::LogInfo( StringStream() << " Max Value" );
value = int64_t( std::numeric_limits< int64_t >::max() );
value = int64_t( value % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, StringUtils::ToString( value ) );
CLogger::LogInfo( StringStream() << " Min Value" );
value = int64_t( std::numeric_limits< int64_t >::min() % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, StringUtils::ToString( value ) );
CLogger::LogInfo( StringStream() << " Lowest Value" );
value = int64_t( std::numeric_limits< int64_t >::lowest() % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, StringUtils::ToString( value ) );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointMaxPrecisionMinDecimals ****" );
}
void CDatabaseFixedPointTest::TestCase_FixedPointSubtraction()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointSubtraction ****" );
CFixedPoint a, b, c;
CLogger::LogInfo( StringStream() << " No underflow" );
a = CFixedPoint( 996, 3, 0 );
b = CFixedPoint( 3, 3, 0 );
BOOST_CHECK_EQUAL( b - a, CFixedPoint( -993, 3, 0 ) );
CLogger::LogInfo( StringStream() << " Integer underflow" );
c = CFixedPoint( 3, CFixedPoint::GetMaxPrecision(), 0 );
b = CFixedPoint( std::numeric_limits< int64_t >::lowest() + 2, CFixedPoint::GetMaxPrecision(), 0 );
BOOST_CHECK_THROW( b - c, CDatabaseException );
CLogger::LogInfo( StringStream() << " Different precisions" );
b = CFixedPoint( 55, 5, 2 );
a = CFixedPoint( 334, 3, 1 );
BOOST_CHECK_EQUAL( a - b, CFixedPoint( 329, 3, 1 ) );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointSubtraction ****" );
}
std::basic_string< char > str_convert< char, wchar_t >( std::basic_string< wchar_t > const & src )
{
std::basic_string< char > dst;
if ( !src.empty() )
{
try
{
std::unique_lock< std::mutex > lock( g_conversionMutex );
std::string szloc = setlocale( LC_CTYPE, "" );
size_t max = src.size();
int length = 1;
const wchar_t * in = src.c_str();
char buffer[32] = { 0 };
dst.reserve( 1 + src.size() * 2 );
while ( *in && length >= 1 )
{
length = wctomb( buffer, *in );
if ( length >= 1 )
{
dst += buffer;
in++;
}
}
setlocale( LC_CTYPE, szloc.c_str() );
}
catch ( std::exception & exc )
{
CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << exc.what() );
}
catch ( ... )
{
CLogger::LogError( StringStream() << ERROR_DB_CONVERSION << INFO_UNKNOWN );
}
}
return std::move( dst );
}
void CDatabaseFixedPointTest::TestCase_FixedPointMedPrecisionMedDecimals()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointMedPrecisionMedDecimals ****" );
int precision = CFixedPoint::GetMaxPrecision() / 2;
int decimals = precision / 2;
int64_t value;
String sval;
CLogger::LogInfo( StringStream() << " Max Value" );
value = int64_t( std::numeric_limits< int64_t >::max() % CFixedPoint::Get10Pow256( precision ) );
sval = StringUtils::ToString( value );
sval.insert( ( sval.rbegin() + decimals ).base(), STR( '.' ) );
CheckFixedPoint( precision, decimals, value, sval );
CLogger::LogInfo( StringStream() << " Min Value" );
value = int64_t( std::numeric_limits< int64_t >::min() % CFixedPoint::Get10Pow256( precision ) );
sval = StringUtils::ToString( value );
sval.insert( ( sval.rbegin() + decimals ).base(), STR( '.' ) );
CheckFixedPoint( precision, decimals, value, sval );
CLogger::LogInfo( StringStream() << " Lowest Value" );
value = int64_t( std::numeric_limits< int64_t >::lowest() % CFixedPoint::Get10Pow256( precision ) );
sval = StringUtils::ToString( value );
sval.insert( ( sval.rbegin() + decimals ).base(), STR( '.' ) );
CheckFixedPoint( precision, decimals, value, sval );
CLogger::LogInfo( StringStream() << " Invalid Value (greater precision than wanted)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< int64_t >::max(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointMaxPrecisionMinDecimals ****" );
}
int main(int argc, char** argv) {
Expr* e = I.dup();
for (int i=1; i<argc; ++i) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 0:
e = append_program(e, &File(stdin, "(standard input)"));
break;
case 'b':
setmode(fileno(stdin), O_BINARY);
setmode(fileno(stdout), O_BINARY);
break;
case 'e':
++i;
if (i == argc) {
usage();
}
e = append_program(e, &StringStream(argv[i]));
break;
default:
usage();
}
} else {
FILE* f = fopen(argv[i], "r");
if (!f) {
fprintf(stderr, "Unable to open the file \"%s\".\n", argv[i]);
exit(1);
}
e = append_program(e, &File(f, argv[i]));
}
}
e = Expr::partial_apply(e, new Expr(Expr::LazyRead));
for (;;) {
int ch = church2int(car(e->dup()));
if (ch >= 256)
return ch-256;
putchar(ch);
e = cdr(e);
}
}
void Geometry::prepare( uint32_t & faceCount
, uint32_t & vertexCount )
{
if ( !m_listCreated )
{
MeshSPtr mesh = getMesh();
if ( mesh )
{
uint32_t nbFaces = mesh->getFaceCount();
uint32_t nbVertex = mesh->getVertexCount();
faceCount += nbFaces;
vertexCount += nbVertex;
mesh->computeContainers();
Logger::logInfo( StringStream()
<< cuT( "Geometry [" ) << getName()
<< cuT( "] - NbVertex: " ) << nbVertex
<< cuT( ", NbFaces: " ) << nbFaces );
m_listCreated = mesh->getSubmeshCount() > 0;
}
}
}
void CDatabaseFixedPointTest::TestCase_FixedPointMinPrecision()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointMinPrecision ****" );
int precision = CFixedPoint::GetMinPrecision();
int decimals = 0;
int64_t value;
CLogger::LogInfo( StringStream() << " Max Value" );
value = int64_t( std::numeric_limits< int64_t >::max() % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, STR( "0" ) );
CLogger::LogInfo( StringStream() << " Min Value" );
value = int64_t( std::numeric_limits< int64_t >::min() % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, STR( "0" ) );
CLogger::LogInfo( StringStream() << " Lowest Value" );
value = int64_t( std::numeric_limits< int64_t >::lowest() % CFixedPoint::Get10Pow256( precision ) );
CheckFixedPoint( precision, decimals, value, STR( "0" ) );
CLogger::LogInfo( StringStream() << " Invalid Value (greater precision than allowed)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< int64_t >::max(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointMinPrecision ****" );
}
void CDatabaseFixedPointTest::TestCase_FixedPointAddition()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointAddition ****" );
CFixedPoint a, b, c;
CLogger::LogInfo( StringStream() << " No overflow" );
a = CFixedPoint( 996, 3, 0 );
b = CFixedPoint( 3, 3, 0 );
BOOST_CHECK_EQUAL( a + b, CFixedPoint( 999, 3, 0 ) );
CLogger::LogInfo( StringStream() << " Precision overflow" );
b = CFixedPoint( 4, 3, 0 );
BOOST_CHECK_THROW( a + b, CDatabaseException );
CLogger::LogInfo( StringStream() << " Integer overflow" );
c = CFixedPoint( 3, CFixedPoint::GetMaxPrecision(), 0 );
b = CFixedPoint( std::numeric_limits< int64_t >::max() - 2, CFixedPoint::GetMaxPrecision(), 0 );
BOOST_CHECK_THROW( c + b, CDatabaseException );
CLogger::LogInfo( StringStream() << " Different precisions" );
b = CFixedPoint( 55, 5, 2 );
a = CFixedPoint( 334, 3, 1 );
BOOST_CHECK_EQUAL( a + b, CFixedPoint( 339, 3, 1 ) );
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointAddition ****" );
}
String slurp(IStream& in) {
return static_cast<StringStream const&>(StringStream() << in.rdbuf()).str();
}
void CDatabaseValueTest::TestCase_ValueGetPtr()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_ValueGetPtr ****" );
std::random_device generator;
CLogger::LogInfo( StringStream() << " EFieldType_BIT" );
ValueChecks< EFieldType_BIT >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_SINT8" );
ValueChecks< EFieldType_SINT8 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_SINT16" );
ValueChecks< EFieldType_SINT16 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_SINT24" );
ValueChecks< EFieldType_SINT24 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_SINT32" );
ValueChecks< EFieldType_SINT32 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_SINT64" );
ValueChecks< EFieldType_SINT64 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_UINT8" );
ValueChecks< EFieldType_UINT8 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_UINT16" );
ValueChecks< EFieldType_UINT16 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_UINT24" );
ValueChecks< EFieldType_UINT24 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_UINT32" );
ValueChecks< EFieldType_UINT32 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_UINT64" );
ValueChecks< EFieldType_UINT64 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_FLOAT32" );
ValueChecks< EFieldType_FLOAT32 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_FLOAT64" );
ValueChecks< EFieldType_FLOAT64 >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_FIXED_POINT" );
ValueChecks< EFieldType_FIXED_POINT >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_CHAR" );
ValueChecks< EFieldType_CHAR >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_VARCHAR" );
ValueChecks< EFieldType_VARCHAR >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_TEXT" );
ValueChecks< EFieldType_TEXT >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_NCHAR" );
ValueChecks< EFieldType_NCHAR >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_NVARCHAR" );
ValueChecks< EFieldType_NVARCHAR >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_NTEXT" );
ValueChecks< EFieldType_NTEXT >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_DATE" );
ValueChecks< EFieldType_DATE >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_DATETIME" );
ValueChecks< EFieldType_DATETIME >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_TIME" );
ValueChecks< EFieldType_TIME >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_BINARY" );
ValueChecks< EFieldType_BINARY >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_VARBINARY" );
ValueChecks< EFieldType_VARBINARY >::PtrValue( generator );
CLogger::LogInfo( StringStream() << " EFieldType_BLOB" );
ValueChecks< EFieldType_BLOB >::PtrValue( generator );
CLogger::LogInfo( StringStream() << "**** End TestCase_ValueGetPtr ****" );
}
void CDatabaseFixedPointTest::TestCase_FixedPointConstruction()
{
CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointConstruction ****" );
int precision = CFixedPoint::GetMaxPrecision() / 2;
int decimals = precision / 2;
CLogger::LogInfo( StringStream() << " From double" );
{
CLogger::LogInfo( StringStream() << " Max Value (Precision overflow)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< double >::max(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Min Value" );
BOOST_CHECK_EQUAL( CFixedPoint( std::numeric_limits< double >::min(), precision, decimals ).ToDouble(), 0.0 );
CLogger::LogInfo( StringStream() << " Lowest Value (Precision overflow)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< double >::lowest(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Random valid Value" );
{
std::random_device generator;
double value = fmod( DatabaseUtils::Helpers< EFieldType_FLOAT64 >::GetRandomValue( generator ), 100000.00 );
CFixedPoint fp( value, precision, decimals );
BOOST_CHECK_LT( value - fp.ToDouble(), pow( 10, -decimals ) );
}
}
CLogger::LogInfo( StringStream() << " From float" );
{
CLogger::LogInfo( StringStream() << " Max Value (Precision overflow)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< float >::max(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Min Value" );
BOOST_CHECK_EQUAL( CFixedPoint( std::numeric_limits< float >::min(), precision, decimals ).ToDouble(), 0.0 );
CLogger::LogInfo( StringStream() << " Lowest Value (Precision overflow)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< float >::lowest(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Random valid Value" );
{
std::random_device generator;
float value = fmod( DatabaseUtils::Helpers< EFieldType_FLOAT32 >::GetRandomValue( generator ), 100000.00f );
CFixedPoint fp( value, precision, decimals );
BOOST_CHECK_LT( value - fp.ToFloat(), pow( 10, -decimals ) );
}
}
CLogger::LogInfo( StringStream() << " From int32_t" );
{
CLogger::LogInfo( StringStream() << " Max Value" );
{
int32_t value = std::numeric_limits< int32_t >::max();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), int32_t( value / pow( 10, decimals ) ) );
}
CLogger::LogInfo( StringStream() << " Min Value" );
{
int32_t value = std::numeric_limits< int32_t >::min();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), int32_t( value / pow( 10, decimals ) ) );
}
CLogger::LogInfo( StringStream() << " Lowest Value" );
{
int32_t value = std::numeric_limits< int32_t >::lowest();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), int32_t( value / pow( 10, decimals ) ) );
}
}
CLogger::LogInfo( StringStream() << " From uint32_t" );
{
CLogger::LogInfo( StringStream() << " Max Value" );
{
uint32_t value = std::numeric_limits< uint32_t >::max();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), uint32_t( value / pow( 10, decimals ) ) );
}
CLogger::LogInfo( StringStream() << " Min Value" );
{
uint32_t value = std::numeric_limits< uint32_t >::min();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), uint32_t( value / pow( 10, decimals ) ) );
}
CLogger::LogInfo( StringStream() << " Lowest Value" );
{
uint32_t value = std::numeric_limits< uint32_t >::lowest();
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToInt32(), uint32_t( value / pow( 10, decimals ) ) );
}
}
CLogger::LogInfo( StringStream() << " From uint64_t" );
{
std::random_device generator;
CLogger::LogInfo( StringStream() << " Max Value (Precision overflow)" );
BOOST_CHECK_THROW( CFixedPoint( std::numeric_limits< uint64_t >::max(), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Min Value" );
BOOST_CHECK_EQUAL( CFixedPoint( std::numeric_limits< uint64_t >::min(), precision, decimals ).ToUInt64(), 0 );
CLogger::LogInfo( StringStream() << " Lowest Value" );
BOOST_CHECK_EQUAL( CFixedPoint( std::numeric_limits< uint64_t >::lowest(), precision, decimals ).ToUInt64(), 0 );
CLogger::LogInfo( StringStream() << " Random valid Value" );
uint64_t value = DatabaseUtils::Helpers< EFieldType_UINT64 >::GetRandomValue( generator ) % uint64_t( pow( 10, precision ) );
BOOST_CHECK_EQUAL( CFixedPoint( value, precision, decimals ).ToUInt64(), uint64_t( value / pow( 10, decimals ) ) );
}
CLogger::LogInfo( StringStream() << " From String" );
{
CLogger::LogInfo( StringStream() << " Precision overflow in integer value" );
BOOST_CHECK_THROW( CFixedPoint( STR( "12345678901" ), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Precision overflow in floating point value" );
BOOST_CHECK_THROW( CFixedPoint( STR( "12345678901.23" ), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Precision overflow, hidden by decimals" );
BOOST_CHECK_THROW( CFixedPoint( STR( "1234567890" ), precision, decimals ), CDatabaseException );
CLogger::LogInfo( StringStream() << " Negative integer Value" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "-12345" ), precision, decimals ).ToInt64(), -12345 );
CLogger::LogInfo( StringStream() << " Positive integer Value" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "12345" ), precision, decimals ).ToInt64(), 12345 );
CLogger::LogInfo( StringStream() << " Negative floating point Value" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "-12345.6789" ), precision, decimals ).ToDouble(), -12345.6789 );
CLogger::LogInfo( StringStream() << " Positive floating point Value, not enough decimals" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "12345.6789" ), precision, decimals ).ToDouble(), 12345.6789 );
CLogger::LogInfo( StringStream() << " Positive floating point Value, good decimals count" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "1234.56789" ), precision, decimals ).ToDouble(), 1234.56789 );
CLogger::LogInfo( StringStream() << " Positive floating point Value, more decimals than needed" );
BOOST_CHECK_EQUAL( CFixedPoint( STR( "123.456789" ), precision, decimals ).ToDouble(), 123.45678 );
}
CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointConstruction ****" );
}
/*!
Read a polytope from a text file. This can be text files using the H-representation(cut of hyperplanes)
or V-represention(convex hull of vertices). Redundant hyperplanes or vertices are allowed, these will
be sorted out by polymake. A third option is to use a text file created by polymake.
@param P Pointer for the polytope which one wants to read from file
@param filename A path to the file to read from
@return 0 if unsuccessfull, 1 otherwise
*/
int readPolytopeFromFile(perl::Object* P, const char* filename)
{
// perl::Object p("Polytope<Rational>");
// Matrix<Rational> m(4,4);
// for(int i=0; i<4; ++i)
// for(int j=0; j<4; ++j)
// m(i,j) = (0==j || j==i+1) ? 1.0 : 0.0;
// p.take("POINTS") << m;
// Rational r = p.give("VOLUME");
// cout << "vol " << r << endl;
// //return 1;
//
//
// P->take("POINTS") << m;
// Rational r2 = P->give("VOLUME");
// cout << "vol " << r2 << endl;
// return 1;
FILE* pInput;
char chBuffer[INPUT_BUFFER_SIZE];
int fileFormat = 0; // 0 V-Rep 1 H-Rep 2-latpack Format
double tmp[4];
pInput = fopen(filename, "r");
if(!pInput)
{
printf("error reading file\n");
return 0;
}
// first, check plain text or polymake xml file
getNextLine(chBuffer, pInput);
//fgets(chBuffer, INPUT_BUFFER_SIZE, pInput);
//cout << chBuffer << endl;
if('V' != chBuffer[0] && 'H' != chBuffer[0] && 'N' != chBuffer[0] && '#' != chBuffer[0])
{
// load from polymake xml file
*P = CallPolymakeFunction("load",filename);
fclose(pInput);
return 1;
}
switch(chBuffer[0])
{
case 'V':
fileFormat = 0;
break;
case 'H':
fileFormat = 1;
break;
case 'N': // fortran format
fileFormat = 2;
break;
case '#':
fileFormat = 3; // VRML file (starts with #VRML
break;
default:
printf("WARNING: unknown file format...\n");
}
switch(fileFormat)
{
case 0: // Vertices
{
int numVertices = 0;
getNextLine(chBuffer, pInput);
sscanf(chBuffer, "%d", &numVertices);
Matrix<Rational> mat(numVertices,DIM3 + 1);
for(int i=0; i<numVertices; ++i)
{
if(!getNextLine(chBuffer, pInput))
reportError(-1, "reading input", "too few lines in file", __FILE__, __LINE__);
sscanf(chBuffer, "%lf %lf %lf", &tmp[0], &tmp[1], &tmp[2]);
mat(i,0) = 1.0; //Rational(1.); // homogenous coordinates for polymake
mat(i,1) = tmp[0]; //Rational(tmp[0]);
mat(i,2) = tmp[1]; //Rational(tmp[1]);
mat(i,3) = tmp[2]; //Rational(tmp[2]);
// mat(i,0) = Rational(1.0); // homogenous coordinates for polymake
// mat(i,1) = Rational(tmp[0]);
// mat(i,2) = Rational(tmp[1]);
// mat(i,3) = Rational(tmp[2]);
}
//cout << mat << endl;
P->take("POINTS") << mat;
break;
}
case 1: // Hyperplanes
{
int numInequalities;
getNextLine(chBuffer, pInput);
sscanf(chBuffer, "%d", &numInequalities);
//Matrix<double> mat(numLines,DIM3 + 1);
Matrix<Rational> mat(numInequalities,DIM3 + 1);
for(int i=0; i<numInequalities; ++i)
{
if(!getNextLine(chBuffer, pInput))
reportError(-1, "reading input", "too few lines in file", __FILE__, __LINE__);
sscanf(chBuffer, "%lf %lf %lf %lf", &tmp[0], &tmp[1], &tmp[2], &tmp[3]);
mat(i,0) = tmp[3]; //Rational(tmp[3]);
mat(i,1) = -tmp[0]; //Rational(tmp[0]);
mat(i,2) = -tmp[1]; //Rational(tmp[1]);
mat(i,3) = -tmp[2]; //Rational(tmp[2]);
}
//cout << mat << endl;
P->take("INEQUALITIES") << mat;
break;
}
case 2: // Fortran format
{
// printf("case2 \n");
int numInequalities;
getNextLine(chBuffer, pInput);
sscanf(chBuffer, "%d", &numInequalities);
//Matrix<double> mat(numLines,DIM3 + 1);
//Matrix<Rational> mat(numInequalities,DIM3 + 1);
Matrix<double> mat(numInequalities,DIM3 + 1);
// printf("ineq %d\n", numInequalities);
// skip description lines
getNextLine(chBuffer, pInput);
getNextLine(chBuffer, pInput);
getNextLine(chBuffer, pInput);
for(int i=0; i<numInequalities; ++i)
{
// skip empty lines between the inequalities
getNextLine(chBuffer, pInput);
for(int j=0; j<4; ++j)
{
if(!getNextLine(chBuffer, pInput))
reportError(-1, "reading input", "too few lines in file", __FILE__, __LINE__);
sscanf(chBuffer, "%lf", &tmp[j]);
}
mat(i,0) = tmp[3]; //Rational(tmp[3]);
mat(i,1) = -tmp[0]; //Rational(tmp[0]);
mat(i,2) = -tmp[1]; //Rational(tmp[1]);
mat(i,3) = -tmp[2]; //Rational(tmp[2]);
//printf("ineq %lf %lf %lf %lf\n",tmp[0],tmp[1],tmp[2],tmp[3]);
}
// cout << mat << endl;
// printf("asdf \n");
P->take("INEQUALITIES") << mat;
// printf("asdff \n");
// Matrix<double> rFacets = P->give("FACETS");
// cout << "fresh facets" << std::endl << rFacets << endl;
break;
}
case 3:
{
std::ifstream is;
is.open(filename);
std::string line;
std::string const searchTag("Coordinate");
std::string const searchClosingPar("]");
Matrix<Rational> mat(0,DIM3 + 1);
while( getline(is, line) )
{
// cout << line << endl;
std::size_t found = line.find(searchTag);
if (found!=std::string::npos)
{
getline(is, line); // this line contains point[ or something
getline(is, line);
for(int i=0; line.find(searchClosingPar)==std::string::npos; ++i)
{
mat.resize(i+1, DIM3 + 1);
std::stringstream StringStream(line);
// std::cout << line << endl;
double d[3]={0.0, 0.0, 0.0};
StringStream >> d[0] >> d[1] >> d[2];
mat(i,0) = 1.0;
mat(i,1) = d[0];
mat(i,2) = d[1];
mat(i,3) = d[2];
//StringStream >> mat(i,1) >> mat(i,2) >> mat(i,3);
// cout << d[0] << " " << d[1] << " " << d[2] << endl;
getline(is, line);
}
break;
}
}
// cout << mat;
P->take("POINTS") << mat;
//
// mat.resize(2, DIM3 + 1);
//
// for(int i=0; i<numVertices; ++i)
// {
// if(!getNextLine(chBuffer, pInput))
// reportError(-1, "reading input", "too few lines in file", __FILE__, __LINE__);
//
// sscanf(chBuffer, "%lf %lf %lf", &tmp[0], &tmp[1], &tmp[2]);
// mat(i,0) = 1.0; //Rational(1.); // homogenous coordinates for polymake
// mat(i,1) = tmp[0]; //Rational(tmp[0]);
// mat(i,2) = tmp[1]; //Rational(tmp[1]);
// mat(i,3) = tmp[2]; //Rational(tmp[2]);
// // mat(i,0) = Rational(1.0); // homogenous coordinates for polymake
// // mat(i,1) = Rational(tmp[0]);
// // mat(i,2) = Rational(tmp[1]);
// // mat(i,3) = Rational(tmp[2]);
// }
// //cout << mat << endl;
// P->take("POINTS") << mat;
break;
}
default:
printf("Warning: unknown file format\n");
}
void
ConvertToFloat(const std::string& _krString, float& _frReturnValue)
{
std::stringstream StringStream(_krString);
StringStream >> _frReturnValue;
}
void
ConvertToInt(const std::string& _krString, int& _irReturnValue)
{
std::stringstream StringStream(_krString);
StringStream >> _irReturnValue;
}
