// read and create items from a rss document
void RssParser::parseFeed(const ParsingJob& job)
{
qDebug() << Q_FUNC_INFO << job.feedUrl << job.filePath;
QFile fileRss(job.filePath);
if (!fileRss.open(QIODevice::ReadOnly | QIODevice::Text)) {
reportFailure(job, tr("Failed to open downloaded RSS file."));
return;
}
QXmlStreamReader xml(&fileRss);
bool found_channel = false;
while (xml.readNextStartElement()) {
if (xml.name() == "rss") {
// Find channels
while (xml.readNextStartElement()) {
if (xml.name() == "channel") {
parseRSSChannel(xml, job.feedUrl);
found_channel = true;
break;
} else {
qDebug() << "Skip rss item: " << xml.name();
xml.skipCurrentElement();
}
}
break;
}
else if (xml.name() == "feed") { // Atom feed
parseAtomChannel(xml, job.feedUrl);
found_channel = true;
break;
} else {
qDebug() << "Skip root item: " << xml.name();
xml.skipCurrentElement();
}
}
if (xml.hasError()) {
reportFailure(job, xml.errorString());
return;
}
if (!found_channel) {
reportFailure(job, tr("Invalid RSS feed at %1.").arg(job.feedUrl));
return;
}
// Clean up
fileRss.close();
emit feedParsingFinished(job.feedUrl, QString());
fsutils::forceRemove(job.filePath);
}
CPPUNIT_NS_BEGIN
bool
DefaultProtector::protect( const Functor &functor,
const ProtectorContext &context )
{
try
{
return functor();
}
catch ( Exception &failure )
{
reportFailure( context, failure );
}
catch ( std::exception &e )
{
std::string shortDescription( "uncaught exception of type " );
#if CPPUNIT_USE_TYPEINFO_NAME
shortDescription += TypeInfoHelper::getClassName( typeid(e) );
#else
shortDescription += "std::exception (or derived).";
#endif
Message message( shortDescription, e.what() );
reportError( context, message );
}
catch ( ... )
{
reportError( context,
Message( "uncaught exception of unknown type") );
}
return false;
}
void maFailRequest(MaConn *conn, int code, cchar *fmt, ...)
{
va_list args;
mprAssert(fmt);
va_start(args, fmt);
reportFailure(conn, code, fmt, args);
va_end(args);
}
void
ScriptCommand_AllAlbums::exec()
{
Tomahawk::ScriptCollection* collection = qobject_cast< Tomahawk::ScriptCollection* >( m_collection.data() );
if ( collection == 0 )
{
reportFailure();
return;
}
if ( !m_artist )
{
reportFailure();
return;
}
connect( collection->resolver(), SIGNAL( albumsFound( QList< Tomahawk::album_ptr > ) ),
this, SLOT( onResolverDone( QList< Tomahawk::album_ptr > ) ) );
collection->resolver()->albums( m_collection, m_artist );
}
void
ScriptCommand_AllTracks::exec()
{
Tomahawk::ScriptCollection* collection = qobject_cast< Tomahawk::ScriptCollection* >( m_collection.data() );
if ( collection == 0 )
{
reportFailure();
return;
}
if ( m_album.isNull() )
{
reportFailure();
return;
}
connect( collection->resolver(), SIGNAL( tracksFound( QList< Tomahawk::query_ptr > ) ),
this, SLOT( onResolverDone( QList< Tomahawk::query_ptr > ) ) );
collection->resolver()->tracks( m_collection, m_album );
}
char* MemoryLeakDetector::reallocMemory(TestMemoryAllocator* allocator, char* memory, size_t size, const char* file, int line, bool allocatNodesSeperately)
{
if (memory) {
MemoryLeakDetectorNode* node = memoryTable_.removeNode(memory);
if (node == NULL) {
reportFailure(MEM_LEAK_DEALLOC_NON_ALLOCATED, "<unknown>", 0, 0, NullUnknownAllocator::defaultAllocator(), file, line, allocator);
return NULL;
}
checkForCorruption(node, file, line, allocator, allocatNodesSeperately);
}
return reallocateMemoryAndLeakInformation(allocator, memory, size, file, line, allocatNodesSeperately);
}
/*
* Stop all requests on the current connection. Fail the current request and the processing pipeline.
* Force a connection closure as the client has disconnected or is seriously messed up.
*/
void maFailConnection(MaConn *conn, int code, cchar *fmt, ...)
{
va_list args;
mprAssert(fmt);
if (!conn->requestFailed) {
conn->keepAliveCount = -1;
conn->connectionFailed = 1;
va_start(args, fmt);
reportFailure(conn, code, fmt, args);
va_end(args);
}
}
void maAbortConnection(MaConn *conn, int code, cchar *fmt, ...)
{
va_list args;
mprAssert(fmt);
mprLog(conn, 4, "Abort conn fd %d", conn->sock ? conn->sock->fd : 0);
if (!conn->requestFailed) {
va_start(args, fmt);
reportFailure(conn, code, fmt, args);
va_end(args);
maDisconnectConn(conn);
}
}
void MemoryLeakDetector::deallocMemory(TestMemoryAllocator* allocator, void* memory, const char* file, int line, bool allocatNodesSeperately)
{
if (memory == 0) return;
MemoryLeakDetectorNode* node = memoryTable_.removeNode((char*) memory);
if (node == NULL) {
reportFailure(MEM_LEAK_DEALLOC_NON_ALLOCATED, "<unknown>", 0, 0, NullUnknownAllocator::defaultAllocator(), file, line, allocator);
return;
}
if (!allocator->hasBeenDestroyed()) {
checkForCorruption(node, file, line, allocator, allocatNodesSeperately);
allocator->free_memory((char*) memory, file, line);
}
}
ListResp Client::ps(bool all, int limit, bool size, bool useFilter, ListFilter &filter)
{
auto resource = utils::catstr(apiBase, "/list");
trace("requesting resource at %s", resource());
auto resp = http::client::get(httpSession, resource(), [&](http::client::Request& req) {
// build custom request
if (all) req.args("all", "true");
if (limit) req.args("limit", limit);
if (size) req.args("size", "true");
if (useFilter) req.args("filters", json::encode(filter));
return true;
});
trace("request resource status %d", resp.status());
if (resp.status() != http::Status::OK) {
// request failed
reportFailure(resp);
}
ListResp respObj;
iod::json_decode(respObj, resp());
return respObj;
}
void
DCMsg::messageSendFailed( DCMessenger *messenger )
{
reportFailure( messenger );
}
void OSGConverter::process(const SendRequest& req) {
// std::cout << req;
int width = 640;
int height = 480;
Event::getParam(req.params, "width", width);
Event::getParam(req.params, "height", height);
assert(req.params.find("source") != req.params.end());
assert(req.params.find("format") != req.params.end());
std::string source;
if (!Event::getParam(req.params, "source", source))
reportFailure(req);
std::string dest;
Event::getParam(req.params, "dest", dest);
std::string format;
if (!Event::getParam(req.params, "format", format))
reportFailure(req);
bool autoRotate = true;
if (req.params.find("autorotate") != req.params.end()) {
if (iequals(req.params.find("autorotate")->second.atom, "off") ||
iequals(req.params.find("autorotate")->second.atom, "0") ||
iequals(req.params.find("autorotate")->second.atom, "false")) {
autoRotate = false;
}
}
osg::ref_ptr<osg::Node> model = setupGraph(source, autoRotate);
if (model->asGroup()->getNumChildren() == 0) {
reportFailure(req);
return;
}
osg::ref_ptr<osg::Group> sceneGraph = new osg::Group();
sceneGraph->addChild(model);
osgDB::ReaderWriter::WriteResult result;
osg::ref_ptr<osgDB::ReaderWriter> writer = osgDB::Registry::instance()->getReaderWriterForExtension(format);
if(writer.valid()) {
std::stringstream ss;
result = writer->writeNode(*sceneGraph, ss);
if (result.success()) {
if (dest.length() > 0) {
std::ofstream outFile(dest.c_str());
outFile << ss.str();
}
Data content(ss.str().c_str(), ss.str().size(), URL::getMimeType(format), false);
reportSuccess(req, content);
return;
}
}
/**
* If we failed to interpret the extension as another 3D file, try to make a screenshot.
*/
((osg::MatrixTransform*)model.get())->setMatrix(requestToModelPose(req));
osg::BoundingSphere bs = model->getBound();
// osg::ref_ptr<osg::MatrixTransform> scale = new osg::MatrixTransform();
// scale->setMatrix(osg::Matrix::scale(bs.radius() / 5, bs.radius() / 5, bs.radius() / 5));
// scale->addChild(getOrigin());
// sceneGraph->addChild(scale);
osgViewer::ScreenCaptureHandler::CaptureOperation* cOp = new NameRespectingWriteToFile(
dest,
format,
osgViewer::ScreenCaptureHandler::WriteToFile::OVERWRITE,
req, this);
osgViewer::ScreenCaptureHandler* captureHandler = new osgViewer::ScreenCaptureHandler(cOp, -1);
{
tthread::lock_guard<tthread::recursive_mutex> lock(_viewerMutex);
osgViewer::Viewer viewer;
osg::ref_ptr<osg::GraphicsContext> gc;
viewer.setSceneData(sceneGraph);
viewer.addEventHandler(captureHandler);
captureHandler->startCapture();
osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(ds);
traits->width = width;
traits->height = height;
// this fails with ubuntu in a VM in parallels
traits->pbuffer = true;
gc = osg::GraphicsContext::createGraphicsContext(traits.get());
if (!gc.valid()) {
LOG(ERROR) << "Cannot create GraphicsContext!";
return;
}
if (!traits->width || !traits->height) {
LOG(ERROR) << "Traits returned with zero dimensions";
return;
}
GLenum pbuffer = gc->getTraits()->doubleBuffer ? GL_BACK : GL_FRONT;
viewer.setCameraManipulator(new osgGA::TrackballManipulator());
viewer.getCamera()->setGraphicsContext(gc.get());
viewer.getCamera()->setViewport(new osg::Viewport(0,0,traits->width,traits->height));
viewer.getCamera()->setDrawBuffer(pbuffer);
viewer.getCamera()->setReadBuffer(pbuffer);
double zoom = 1;
CAST_PARAM(req.params, zoom, "zoom", double);
// set background color
viewer.getCamera()->setClearColor(osg::Vec4f(1.0f,1.0f,1.0f,1.0f));
viewer.getCamera()->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
viewer.getCameraManipulator()->setByMatrix(osg::Matrix::lookAt(osg::Vec3d(0,0,bs.radius() * (-3.4 * zoom)), // eye
(osg::Vec3d)bs.center(), // center
osg::Vec3d(0,1,0))); // up
// viewer.home();
// perform one viewer iteration
viewer.realize();
viewer.frame();
viewer.removeEventHandler(captureHandler);
}
// delete(cOp);
// delete(captureHandler);
}
int main(void)
{
uint8_t temp[128];
uint8_t address1[20];
uint8_t address2[20];
uint8_t name[NAME_LENGTH];
uint8_t encryption_key[WALLET_ENCRYPTION_KEY_LENGTH];
uint8_t new_encryption_key[WALLET_ENCRYPTION_KEY_LENGTH];
uint8_t version[4];
uint8_t *address_buffer;
uint8_t one_byte;
AddressHandle *handles_buffer;
AddressHandle ah;
PointAffine public_key;
PointAffine *public_key_buffer;
int abort;
int is_zero;
int abort_duplicate;
int abort_error;
int i;
int j;
initTests(__FILE__);
initWalletTest();
memset(encryption_key, 0, WALLET_ENCRYPTION_KEY_LENGTH);
setEncryptionKey(encryption_key);
// Blank out non-volatile storage area (set to all nulls).
temp[0] = 0;
for (i = 0; i < TEST_FILE_SIZE; i++)
{
fwrite(temp, 1, 1, wallet_test_file);
}
// sanitiseNonVolatileStorage() should nuke everything.
if (sanitiseNonVolatileStorage(0, 0xffffffff) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Cannot nuke NV storage using sanitiseNonVolatileStorage()\n");
reportFailure();
}
// Check that the version field is "wallet not there".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after sanitiseNonVolatileStorage() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_NOTHING_THERE)
{
reportSuccess();
}
else
{
printf("sanitiseNonVolatileStorage() does not set version to nothing there\n");
reportFailure();
}
// initWallet() hasn't been called yet, so nearly every function should
// return WALLET_NOT_THERE somehow.
checkFunctionsReturnWalletNotThere();
// The non-volatile storage area was blanked out, so there shouldn't be a
// (valid) wallet there.
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("initWallet() doesn't recognise when wallet isn't there\n");
reportFailure();
}
// Try creating a wallet and testing initWallet() on it.
memcpy(name, "123456789012345678901234567890abcdefghij", NAME_LENGTH);
if (newWallet(name) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Could not create new wallet\n");
reportFailure();
}
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("initWallet() does not recognise new wallet\n");
reportFailure();
}
if ((getNumAddresses() == 0) && (walletGetLastError() == WALLET_EMPTY))
{
reportSuccess();
}
else
{
printf("New wallet isn't empty\n");
reportFailure();
}
// Check that the version field is "unencrypted wallet".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after newWallet() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_UNENCRYPTED)
{
reportSuccess();
}
else
{
printf("newWallet() does not set version to unencrypted wallet\n");
reportFailure();
}
// Check that sanitise_nv_wallet() deletes wallet.
if (sanitiseNonVolatileStorage(0, 0xffffffff) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Cannot nuke NV storage using sanitiseNonVolatileStorage()\n");
reportFailure();
}
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("sanitiseNonVolatileStorage() isn't deleting wallet\n");
reportFailure();
}
// Make some new addresses, then create a new wallet and make sure the
// new wallet is empty (i.e. check that newWallet() deletes existing
// wallet).
newWallet(name);
if (makeNewAddress(temp, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
newWallet(name);
if ((getNumAddresses() == 0) && (walletGetLastError() == WALLET_EMPTY))
{
reportSuccess();
}
else
{
printf("newWallet() doesn't delete existing wallet\n");
reportFailure();
}
// Unload wallet and make sure everything realises that the wallet is
// not loaded.
if (uninitWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("uninitWallet() failed to do its basic job\n");
reportFailure();
}
checkFunctionsReturnWalletNotThere();
// Load wallet again. Since there is actually a wallet there, this
// should succeed.
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("uninitWallet() appears to be permanent\n");
reportFailure();
}
// Change bytes in non-volatile memory and make sure initWallet() fails
// because of the checksum check.
if (uninitWallet() != WALLET_NO_ERROR)
{
printf("uninitWallet() failed to do its basic job 2\n");
reportFailure();
}
abort = 0;
for (i = 0; i < WALLET_RECORD_LENGTH; i++)
{
if (nonVolatileRead(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV read fail\n");
abort = 1;
break;
}
one_byte++;
if (nonVolatileWrite(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV write fail\n");
abort = 1;
break;
}
if (initWallet() == WALLET_NO_ERROR)
{
printf("Wallet still loads when wallet checksum is wrong, offset = %d\n", i);
abort = 1;
break;
}
one_byte--;
if (nonVolatileWrite(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV write fail\n");
abort = 1;
break;
}
}
if (!abort)
{
reportSuccess();
}
else
{
reportFailure();
}
// Create 2 new wallets and check that their addresses aren't the same
newWallet(name);
if (makeNewAddress(address1, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
newWallet(name);
memset(address2, 0, 20);
memset(&public_key, 0, sizeof(PointAffine));
if (makeNewAddress(address2, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
if (memcmp(address1, address2, 20))
{
reportSuccess();
}
else
{
printf("New wallets are creating identical addresses\n");
reportFailure();
}
// Check that makeNewAddress() wrote to its outputs.
is_zero = 1;
for (i = 0; i < 20; i++)
{
if (address2[i] != 0)
{
is_zero = 0;
break;
}
}
if (is_zero)
{
printf("makeNewAddress() doesn't write the address\n");
reportFailure();
}
else
{
reportSuccess();
}
if (bigIsZero(public_key.x))
{
printf("makeNewAddress() doesn't write the public key\n");
reportFailure();
}
else
{
reportSuccess();
}
// Make some new addresses, up to a limit.
// Also check that addresses are unique.
newWallet(name);
abort = 0;
address_buffer = malloc(MAX_TESTING_ADDRESSES * 20);
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
if (makeNewAddress(&(address_buffer[i * 20]), &public_key) == BAD_ADDRESS_HANDLE)
{
printf("Couldn't create new address in new wallet\n");
abort = 1;
break;
}
for (j = 0; j < i; j++)
{
if (!memcmp(&(address_buffer[i * 20]), &(address_buffer[j * 20]), 20))
{
printf("Wallet addresses aren't unique\n");
abort = 1;
break;
}
}
if (abort)
{
break;
}
}
free(address_buffer);
if (!abort)
{
reportSuccess();
}
else
{
reportFailure();
}
// The wallet should be full now.
// Check that making a new address now causes an appropriate error.
if (makeNewAddress(temp, &public_key) == BAD_ADDRESS_HANDLE)
{
if (walletGetLastError() == WALLET_FULL)
{
reportSuccess();
}
else
{
printf("Creating a new address on a full wallet gives incorrect error\n");
reportFailure();
}
}
else
{
printf("Creating a new address on a full wallet succeeds (it's not supposed to)\n");
reportFailure();
}
// Check that getNumAddresses() fails when the wallet is empty.
newWallet(name);
if (getNumAddresses() == 0)
{
if (walletGetLastError() == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getNumAddresses() doesn't recognise wallet is empty\n");
reportFailure();
}
}
else
{
printf("getNumAddresses() succeeds when used on empty wallet\n");
reportFailure();
}
// Create a bunch of addresses in the (now empty) wallet and check that
// getNumAddresses() returns the right number.
address_buffer = malloc(MAX_TESTING_ADDRESSES * 20);
public_key_buffer = malloc(MAX_TESTING_ADDRESSES * sizeof(PointAffine));
handles_buffer = malloc(MAX_TESTING_ADDRESSES * sizeof(AddressHandle));
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
ah = makeNewAddress(&(address_buffer[i * 20]), &(public_key_buffer[i]));
handles_buffer[i] = ah;
if (ah == BAD_ADDRESS_HANDLE)
{
printf("Couldn't create new address in new wallet\n");
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
if (getNumAddresses() == MAX_TESTING_ADDRESSES)
{
reportSuccess();
}
else
{
printf("getNumAddresses() returns wrong number of addresses\n");
reportFailure();
}
// The wallet should contain unique addresses.
abort_duplicate = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
for (j = 0; j < i; j++)
{
if (!memcmp(&(address_buffer[i * 20]), &(address_buffer[j * 20]), 20))
{
printf("Wallet has duplicate addresses\n");
abort_duplicate = 1;
reportFailure();
break;
}
}
}
if (!abort_duplicate)
{
reportSuccess();
}
// The wallet should contain unique public keys.
abort_duplicate = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
for (j = 0; j < i; j++)
{
if (bigCompare(public_key_buffer[i].x, public_key_buffer[j].x) == BIGCMP_EQUAL)
{
printf("Wallet has duplicate public keys\n");
abort_duplicate = 1;
reportFailure();
break;
}
}
}
if (!abort_duplicate)
{
reportSuccess();
}
// The address handles should start at 1 and be sequential.
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
if (handles_buffer[i] != (AddressHandle)(i + 1))
{
printf("Address handle %d should be %d, but got %d\n", i, i + 1, (int)handles_buffer[i]);
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
// While there's a bunch of addresses in the wallet, check that
// getAddressAndPublicKey() obtains the same address and public key as
// makeNewAddress().
abort_error = 0;
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
ah = handles_buffer[i];
if (getAddressAndPublicKey(address1, &public_key, ah) != WALLET_NO_ERROR)
{
printf("Couldn't obtain address in wallet\n");
abort_error = 1;
reportFailure();
break;
}
if ((memcmp(address1, &(address_buffer[i * 20]), 20))
|| (bigCompare(public_key.x, public_key_buffer[i].x) != BIGCMP_EQUAL)
|| (bigCompare(public_key.y, public_key_buffer[i].y) != BIGCMP_EQUAL))
{
printf("getAddressAndPublicKey() returned mismatching address or public key, ah = %d\n", i);
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
if (!abort_error)
{
reportSuccess();
}
// Test getAddressAndPublicKey() and getPrivateKey() functions using
// invalid and then valid address handles.
if (getAddressAndPublicKey(temp, &public_key, 0) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise 0 as invalid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, 0) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise 0 as invalid address handle\n");
reportFailure();
}
if (getAddressAndPublicKey(temp, &public_key, BAD_ADDRESS_HANDLE) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise BAD_ADDRESS_HANDLE as invalid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, BAD_ADDRESS_HANDLE) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise BAD_ADDRESS_HANDLE as invalid address handle\n");
reportFailure();
}
if (getAddressAndPublicKey(temp, &public_key, handles_buffer[0]) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise valid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, handles_buffer[0]) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise valid address handle\n");
reportFailure();
}
free(address_buffer);
free(public_key_buffer);
free(handles_buffer);
// Check that changeEncryptionKey() works.
memset(new_encryption_key, 0, WALLET_ENCRYPTION_KEY_LENGTH);
new_encryption_key[0] = 1;
if (changeEncryptionKey(new_encryption_key) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Couldn't change encryption key\n");
reportFailure();
}
// Check that the version field is "encrypted wallet".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after changeEncryptionKey() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_IS_ENCRYPTED)
{
reportSuccess();
}
else
{
printf("changeEncryptionKey() does not set version to encrypted wallet\n");
reportFailure();
}
// Check name matches what was given in newWallet().
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't return correct name when wallet is loaded\n");
reportFailure();
}
// Check that getWalletInfo() still works after unloading wallet.
uninitWallet();
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after uninitWallet() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_IS_ENCRYPTED)
{
reportSuccess();
}
else
{
printf("uninitWallet() caused wallet version to change\n");
reportFailure();
}
// Check name matches what was given in newWallet().
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't return correct name when wallet is not loaded\n");
reportFailure();
}
// Change wallet's name and check that getWalletInfo() reflects the
// name change.
initWallet();
memcpy(name, "HHHHH HHHHHHHHHHHHHHHHH HHHHHHHHHHHHHH ", NAME_LENGTH);
if (changeWalletName(name) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("changeWalletName() couldn't change name\n");
reportFailure();
}
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change\n");
reportFailure();
}
// Check that name change is preserved when unloading and loading a
// wallet.
uninitWallet();
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change after unloading wallet\n");
reportFailure();
}
// Check that initWallet() succeeds (changing the name changes the
// checksum, so this tests whether the checksum was updated).
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("initWallet() failed after name change\n");
reportFailure();
}
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change after reloading wallet\n");
reportFailure();
}
// Check that loading the wallet with the old key fails.
uninitWallet();
setEncryptionKey(encryption_key);
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("Loading wallet with old encryption key succeeds\n");
reportFailure();
}
// Check that loading the wallet with the new key succeeds.
uninitWallet();
setEncryptionKey(new_encryption_key);
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Loading wallet with new encryption key fails\n");
reportFailure();
}
// Test the getAddressAndPublicKey() and getPrivateKey() functions on an
// empty wallet.
newWallet(name);
if (getAddressAndPublicKey(temp, &public_key, 0) == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't deal with empty wallets correctly\n");
reportFailure();
}
if (getPrivateKey(temp, 0) == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't deal with empty wallets correctly\n");
reportFailure();
}
fclose(wallet_test_file);
finishTests();
exit(0);
}
void MemoryLeakOutputStringBuffer::reportAllocationDeallocationMismatchFailure(MemoryLeakDetectorNode* node, const char* freeFile, int freeLineNumber, TestMemoryAllocator* freeAllocator, MemoryLeakFailure* reporter)
{
reportFailure("Allocation/deallocation type mismatch\n", node->file_, node->line_, node->size_, node->allocator_, freeFile, freeLineNumber, freeAllocator, reporter);
}
void
DCMsg::messageReceiveFailed( DCMessenger *messenger )
{
reportFailure( messenger );
}
bool
PointAttenuationTest::testPointRendering(GLboolean smooth)
{
// epsilon is the allowed size difference in pixels between the
// expected and actual rendering.
const GLfloat epsilon = (smooth ? 1.5 : 1.0) + 0.0;
GLfloat atten[3];
int count = 0;
// Enable front buffer if you want to see the rendering
glDrawBuffer(GL_FRONT);
glReadBuffer(GL_FRONT);
if (smooth) {
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else {
glDisable(GL_POINT_SMOOTH);
glDisable(GL_BLEND);
}
for (int a = 0; a < 3; a++) {
atten[0] = pow(10.0, -a);
for (int b = -2; b < 3; b++) {
atten[1] = (b == -1) ? 0.0 : pow(10.0, -b);
for (int c = -2; c < 3; c++) {
atten[2] = (c == -1) ? 0.0 : pow(10.0, -c);
PointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, atten);
for (float min = 1.0; min < MAX_SIZE; min += 10) {
PointParameterfARB(GL_POINT_SIZE_MIN_ARB, min);
for (float max = min; max < MAX_SIZE; max += 10) {
PointParameterfARB(GL_POINT_SIZE_MAX_ARB, max);
for (float size = 1.0; size < MAX_SIZE; size += 8) {
glPointSize(size);
// draw column of points
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);
for (float z = -6.0; z <= 6.0; z += 1.0) {
glVertex3f(0, z, z);
}
glEnd();
// test the column of points
for (float z = -6.0; z <= 6.0; z += 1.0) {
count++;
float expected
= expectedSize(size, atten, min, max,
z, smooth);
float actual = measureSize(z);
if (fabs(expected - actual) > epsilon) {
reportFailure(size, atten, min, max,
z, smooth,
expected, actual);
return false;
}
else if(0){
printf("pass z=%f exp=%f act=%f\n",
z, expected, actual);
}
}
}
}
}
}
}
}
reportSuccess(count, smooth);
return true;
}
/** A proper test suite for randomness would be quite big, so this test
* spits out samples into random.dat, where they can be analysed using
* an external program.
*/
int main(int argc, char **argv)
{
uint8_t r[32];
int i, j;
int num_samples;
int abort;
unsigned int bytes_written;
FILE *f;
uint8_t seed[64];
uint8_t keys[64][32];
uint8_t key2[32];
initTests(__FILE__);
// Before outputting samples, do a sanity check that
// generateDeterministic256() actually has different outputs when
// each byte of the seed is changed.
abort = 0;
for (i = 0; i < 64; i++)
{
memset(seed, 0, 64);
seed[i] = 1;
generateDeterministic256(keys[i], seed, 0);
for (j = 0; j < i; j++)
{
if (bigCompare(keys[i], keys[j]) == BIGCMP_EQUAL)
{
printf("generateDeterministic256() is ignoring byte %d of seed\n", i);
abort = 1;
break;
}
}
if (abort)
{
break;
}
}
if (abort)
{
reportFailure();
}
else
{
reportSuccess();
}
// Check that generateDeterministic256() isn't ignoring num.
memset(seed, 0, 64);
seed[0] = 1;
generateDeterministic256(key2, seed, 1);
abort = 0;
for (j = 0; j < 64; j++)
{
if (bigCompare(key2, keys[j]) == BIGCMP_EQUAL)
{
printf("generateDeterministic256() is ignoring num\n");
abort = 1;
break;
}
}
if (abort)
{
reportFailure();
}
else
{
reportSuccess();
}
// Check that generateDeterministic256() is actually deterministic.
generateDeterministic256(key2, seed, 0);
if (bigCompare(key2, keys[0]) != BIGCMP_EQUAL)
{
printf("generateDeterministic256() is not deterministic\n");
reportFailure();
}
else
{
reportSuccess();
}
if (argc != 2)
{
printf("Usage: %s <n>, where <n> is number of 256 bit samples to take\n", argv[0]);
printf("Samples will go into random.dat\n");
exit(1);
}
sscanf(argv[1], "%d", &num_samples);
if (num_samples <= 0)
{
printf("Invalid number of samples specified\n");
exit(1);
}
f = fopen("random.dat", "wb");
if (f == NULL)
{
printf("Could not open random.dat for writing\n");
exit(1);
}
srand(42);
bytes_written = 0;
for (i = 0; i < num_samples; i++)
{
getRandom256(r);
bytes_written += fwrite(r, 1, 32, f);
}
fclose(f);
printf("%u bytes written to random.dat\n", bytes_written);
finishTests();
exit(0);
}
void MemoryLeakDetector::checkForCorruption(MemoryLeakDetectorNode* node, const char* file, int line, TestMemoryAllocator* allocator, bool allocateNodesSeperately)
{
if (!matchingAllocation(node->allocator_, allocator)) reportFailure(MEM_LEAK_ALLOC_DEALLOC_MISMATCH, node->file_, node->line_, node->size_, node->allocator_, file, line, allocator);
else if (!validMemoryCorruptionInformation(node->memory_ + node->size_)) reportFailure(MEM_LEAK_MEMORY_CORRUPTION, node->file_, node->line_, node->size_, node->allocator_, file, line, allocator);
else if (allocateNodesSeperately) allocator->freeMemoryLeakNode((char*) node);
}
void MemoryLeakOutputStringBuffer::reportDeallocateNonAllocatedMemoryFailure(const char* freeFile, int freeLine, TestMemoryAllocator* freeAllocator, MemoryLeakFailure* reporter)
{
reportFailure("Deallocating non-allocated memory\n", "<unknown>", 0, 0, NullUnknownAllocator::defaultAllocator(), freeFile, freeLine, freeAllocator, reporter);
}
bool
VertexProgramTest::testProgram(const VertexProgram &p)
{
const GLfloat r = 0.25;
glProgramStringARB(GL_VERTEX_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(p.progString),
(const GLubyte *) p.progString);
GLenum err = glGetError();
if (err) {
GLint errorPos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
env->log << "OpenGL error " << (int) err << "\n";
env->log << "Invalid Vertex Program:\n";
env->log << p.progString;
env->log << "Error position: " << errorPos << "\n";
env->log << "Error message: " << glGetString(GL_PROGRAM_ERROR_STRING_ARB) << "\n";
return false;
}
// to avoid potential issue with undefined result.depth.z
if (p.expectedZ == DONT_CARE_Z)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin(GL_POLYGON);
glTexCoord2f(0, 0); glVertex2f(-r, -r);
glTexCoord2f(1, 0); glVertex2f( r, -r);
glTexCoord2f(1, 1); glVertex2f( r, r);
glTexCoord2f(0, 1); glVertex2f(-r, r);
glEnd();
GLfloat pixel[4];
glReadPixels(windowSize / 2, windowSize / 2, 1, 1,
GL_RGBA, GL_FLOAT, pixel);
if (0) // debug
printf("%s: Expect: %.3f %.3f %.3f %.3f found: %.3f %.3f %.3f %.3f\n",
p.name,
p.expectedColor[0], p.expectedColor[1],
p.expectedColor[2], p.expectedColor[3],
pixel[0], pixel[1], pixel[2], pixel[3]);
if (!equalColors(pixel, p.expectedColor, p.flags)) {
reportFailure(p.name, p.expectedColor, pixel);
return false;
}
if (p.expectedZ != DONT_CARE_Z) {
GLfloat z;
glReadPixels(windowSize / 2, windowSize / 2, 1, 1,
GL_DEPTH_COMPONENT, GL_FLOAT, &z);
if (!equalDepth(z, p.expectedZ)) {
reportZFailure(p.name, p.expectedZ, z);
return false;
}
}
if (0) // debug
printf("%s passed\n", p.name);
return true;
}
void MemoryLeakOutputStringBuffer::reportMemoryCorruptionFailure(MemoryLeakDetectorNode* node, const char* freeFile, int freeLineNumber, TestMemoryAllocator* freeAllocator, MemoryLeakFailure* reporter)
{
reportFailure("Memory corruption (written out of bounds?)\n", node->file_, node->line_, node->size_, node->allocator_, freeFile, freeLineNumber, freeAllocator, reporter);
}
/** Call nearly all wallet functions and make sure they
* return #WALLET_NOT_THERE somehow. This should only be called if a wallet
* is not loaded. */
static void checkFunctionsReturnWalletNotThere(void)
{
uint8_t temp[128];
uint32_t check_num_addresses;
AddressHandle ah;
PointAffine public_key;
// newWallet() not tested because it calls initWallet() when it's done.
ah = makeNewAddress(temp, &public_key);
if ((ah == BAD_ADDRESS_HANDLE) && (walletGetLastError() == WALLET_NOT_THERE))
{
reportSuccess();
}
else
{
printf("makeNewAddress() doesn't recognise when wallet isn't there\n");
reportFailure();
}
check_num_addresses = getNumAddresses();
if ((check_num_addresses == 0) && (walletGetLastError() == WALLET_NOT_THERE))
{
reportSuccess();
}
else
{
printf("getNumAddresses() doesn't recognise when wallet isn't there\n");
reportFailure();
}
if (getAddressAndPublicKey(temp, &public_key, 0) == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise when wallet isn't there\n");
reportFailure();
}
if (getPrivateKey(temp, 0) == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise when wallet isn't there\n");
reportFailure();
}
if (changeEncryptionKey(temp) == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("changeEncryptionKey() doesn't recognise when wallet isn't there\n");
reportFailure();
}
if (changeWalletName(temp) == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("changeWalletName() doesn't recognise when wallet isn't there\n");
reportFailure();
}
}
