245 lines
6.6 KiB
C++
245 lines
6.6 KiB
C++
/*
|
|
Test-ZTransform.cpp
|
|
Author: Charles Lena <cmlena@762studios.com>
|
|
Created: 3/29/2012
|
|
|
|
Purpose:
|
|
|
|
Tests to ensure that the math transform routines function accurately.
|
|
*/
|
|
|
|
#include "ZUnitTest.hpp"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <climits>
|
|
#include <cfloat>
|
|
#include <math.h>
|
|
#include <SST/SST_File.h>
|
|
#include <ZUtil/ZBinaryDataWriter.hpp>
|
|
|
|
inline bool fpcomp(float typed_1, float typed_2, float tol = FLT_EPSILON) {
|
|
return (abs(typed_1 - typed_2) <= tol);
|
|
}
|
|
inline bool dpcomp(double typed_1, double typed_2, double tol = DBL_EPSILON) {
|
|
return (abs(typed_1 - typed_2) <= tol);
|
|
}
|
|
/* class ZBinaryDataWriter
|
|
{
|
|
protected:
|
|
SST_File file;
|
|
bool swapEndian;
|
|
|
|
public:
|
|
ZBinaryDataWriter( SST_File _file, bool _swapEndian = false)
|
|
: file(_file), swapEndian(_swapEndian)
|
|
{
|
|
}
|
|
|
|
~ZBinaryDataWriter() {}
|
|
|
|
bool GetWillSwap();
|
|
void SetWillSwap( bool _swap );
|
|
|
|
void WriteChar( const char _out);
|
|
inline void WriteInt8( const int8_t _out) { WriteChar( _out); }
|
|
void WriteInt16( const int16_t _out);
|
|
void WriteInt32( const int32_t _out);
|
|
void WriteInt64( const int64_t _out);
|
|
void WriteUInt16( const uint16_t _out);
|
|
void WriteUInt32( const uint32_t _out);
|
|
void WriteUInt64( const uint64_t _out);
|
|
void WriteFloat( const float _out);
|
|
void WriteDouble( const double _out);
|
|
|
|
void WriteCharArray( const char* _out, size_t _count);
|
|
void WriteInt16Array( const int16_t* _out, size_t _count);
|
|
void WriteInt32Array( const int32_t* _out, size_t _count);
|
|
void WriteInt64Array( const int64_t* _out, size_t _count);
|
|
void WriteUInt16Array( const uint16_t* _out, size_t _count);
|
|
void WriteUInt32Array( const uint32_t* _out, size_t _count);
|
|
void WriteUInt64Array( const uint64_t* _out, size_t _count);
|
|
void WriteFloatArray( const float* _out, size_t _count);
|
|
void WriteDoubleArray( const double* _out, size_t _count);
|
|
}; */
|
|
static const char* testGetWillSwap();
|
|
static const char* testSetWillSwap();
|
|
static const char* testWriteChar();
|
|
static const char* testWriteChar();
|
|
static const char* testWriteInt16();
|
|
static const char* testWriteInt32();
|
|
static const char* testWriteInt64();
|
|
static const char* testWriteUInt16();
|
|
static const char* testWriteUInt32();
|
|
static const char* testWriteUInt64();
|
|
static const char* testWriteFloat();
|
|
static const char* testWriteDouble();
|
|
static const char* testWriteCharArray();
|
|
static const char* testWriteInt16Array();
|
|
static const char* testWriteInt32Array();
|
|
static const char* testWriteInt64Array();
|
|
static const char* testWriteUInt16Array();
|
|
static const char* testWriteUInt32Array();
|
|
static const char* testWriteUInt64Array();
|
|
static const char* testWriteFloatArray();
|
|
static const char* testWriteDoubleArray();
|
|
|
|
//List of unit tests
|
|
ZUnitTest ZBinaryDataWriterUnitTests[] =
|
|
{
|
|
{"testGetWillSwap",testGetWillSwap},
|
|
{"testSetWillSwap",testSetWillSwap},
|
|
{"testWriteChar",testWriteChar},
|
|
{"testWriteChar",testWriteChar},
|
|
{"testWriteInt16",testWriteInt16},
|
|
{"testWriteInt32",testWriteInt32},
|
|
{"testWriteInt64",testWriteInt64},
|
|
{"testWriteUInt16",testWriteUInt16},
|
|
{"testWriteUInt32",testWriteUInt32},
|
|
{"testWriteUInt64",testWriteUInt64},
|
|
{"testWriteFloat",testWriteFloat},
|
|
{"testWriteDouble",testWriteDouble},
|
|
{"testWriteCharArray",testWriteCharArray},
|
|
{"testWriteInt16Array",testWriteInt16Array},
|
|
{"testWriteInt32Array",testWriteInt32Array},
|
|
{"testWriteInt64Array",testWriteInt64Array},
|
|
{"testWriteUInt16Array",testWriteUInt16Array},
|
|
{"testWriteUInt32Array",testWriteUInt32Array},
|
|
{"testWriteUInt64Array",testWriteUInt64Array},
|
|
{"testWriteFloatArray",testWriteFloatArray},
|
|
{"testWriteDoubleArray",testWriteDoubleArray},
|
|
};
|
|
|
|
DECLARE_ZTESTBLOCK(ZBinaryDataWriter);
|
|
|
|
// =======================================
|
|
#include <stdio.h>
|
|
#if SST_COMPILER == SST_COMPILER_MSVC
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4127)
|
|
#endif
|
|
static const char* testGetWillSwap(){
|
|
SST_File File;
|
|
bool result;
|
|
File = SST_OS_OpenFile("test.dat",SST_OPEN_WRITE);
|
|
ZBinaryDataWriter Z( File , false);
|
|
result = Z.GetWillSwap();
|
|
SST_OS_CloseFile(File);
|
|
|
|
|
|
TASSERT(result == false,"GetWillSwap() failed to detect false!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testSetWillSwap(){
|
|
SST_File File;
|
|
bool result;
|
|
File = SST_OS_OpenFile("test.dat",SST_OPEN_WRITE);
|
|
ZBinaryDataWriter Z( File , false);
|
|
Z.SetWillSwap(true);
|
|
result = Z.GetWillSwap();
|
|
SST_OS_CloseFile(File);
|
|
|
|
|
|
TASSERT(result == true,"SetWillSwap() failed to detect true!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteChar(){
|
|
SST_File File;
|
|
bool result;
|
|
File = SST_OS_OpenFile("char.dat",SST_OPEN_WRITE);
|
|
ZBinaryDataWriter Z( File , false);
|
|
Z.WriteChar('C');
|
|
SST_OS_CloseFile(File);
|
|
|
|
|
|
TASSERT(result == false,"WriteChar() failed to detect false!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt16(){
|
|
bool result;
|
|
|
|
TASSERT(result == false,"WriteInt16() failed to produce desired results!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt32(){
|
|
TASSERT(false,"WriteInt32() failed to produce the desired results!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt64(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt16(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt32(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt64(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteFloat(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteDouble(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteCharArray(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt16Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt32Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteInt64Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt16Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt32Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteUInt64Array(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteFloatArray(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
static const char* testWriteDoubleArray(){
|
|
|
|
TASSERT(false,"Test Not Implemented Yet!");
|
|
return ZTEST_SUCCESS;
|
|
}
|
|
#if SST_COMPILER == SST_COMPILER_MSVC
|
|
#pragma warning(pop)
|
|
#endif
|