void TupleDataSet::init() {
// First pass: count examples.
nExamples = 0;
unsigned int x;
file->rewind();
file->read(&x, sizeof(unsigned int), 1);
ASSERT_ERROR( x == observation.dim() );
file->read(&x, sizeof(unsigned int), 1);
ASSERT_ERROR( x == lastAction.dim() );
lastObservation.loadData(file);
unsigned int size = file->size();
while (file->tell() < size) {
lastAction.loadData(file);
lastObservation.loadData(file);
nExamples++;
}
// Allocate example.
DataSet::init();
// Go back to start.
reset();
}
static void hw_aes_hash_check_data_size(const hw_aes_hash_setup* setup)
{
switch (setup->mode) {
case HW_AES_ECB:
// In ECB mode the dataSize needs to be a multiple of 16.
ASSERT_ERROR(setup->dataSize % 0x10 == 0);
break;
case HW_AES_CBC:
case HW_AES_CTR:
// If more data is to come in CBC or CTR mode the dataSize needs to be a multiple of 16.
if (setup->moreDataToCome) {
ASSERT_ERROR(setup->dataSize % 0x10 == 0);
}
break;
case HW_HASH_MD5:
case HW_HASH_SHA_1:
case HW_HASH_SHA_256_224:
case HW_HASH_SHA_256:
case HW_HASH_SHA_384:
case HW_HASH_SHA_512:
case HW_HASH_SHA_512_224:
case HW_HASH_SHA_512_256:
// If more data is to come in hash mode the dataSize needs to be a multiple of 8.
if (setup->moreDataToCome) {
ASSERT_ERROR(setup->dataSize % 0x8 == 0);
}
break;
}
}
/// =-=-=-=-=-=-=-
/// @brief used to allow the resource to determine which host
/// should provide the requested operation
irods::error load_balanced_redirect(
irods::resource_plugin_context& _ctx,
const std::string* _opr,
const std::string* _curr_host,
irods::hierarchy_parser* _out_parser,
float* _out_vote ) {
irods::error result = SUCCESS();
// =-=-=-=-=-=-=-
// check incoming parameters
irods::error err = load_balanced_check_params< irods::file_object >( _ctx );
if ( ( result = ASSERT_PASS( err, "Invalid resource context." ) ).ok() ) {
if ( ( result = ASSERT_ERROR( _opr && _curr_host && _out_parser && _out_vote, SYS_INVALID_INPUT_PARAM,
"Invalid parameters." ) ).ok() ) {
// =-=-=-=-=-=-=-
// get the object's hier string
irods::file_object_ptr file_obj = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );
std::string hier = file_obj->resc_hier( );
// =-=-=-=-=-=-=-
// get the object's hier string
std::string name;
err = _ctx.prop_map().get< std::string >( irods::RESOURCE_NAME, name );
if ( ( result = ASSERT_PASS( err, "Failed to get property: \"%s\".", irods::RESOURCE_NAME.c_str() ) ).ok() ) {
// =-=-=-=-=-=-=-
// add ourselves into the hierarch before calling child resources
_out_parser->add_child( name );
// =-=-=-=-=-=-=-
// test the operation to determine which choices to make
if ( irods::OPEN_OPERATION == ( *_opr ) ||
irods::WRITE_OPERATION == ( *_opr ) ) {
std::string err_msg = "failed in resolve hierarchy for [" + ( *_opr ) + "]";
err = load_balanced_redirect_for_open_operation( _ctx, _opr, _curr_host, _out_parser, _out_vote );
result = ASSERT_PASS( err, err_msg );
}
else if ( irods::CREATE_OPERATION == ( *_opr ) ) {
// =-=-=-=-=-=-=-
// get the next_child resource for create
irods::resource_ptr resc;
std::string err_msg = "failed in resolve hierarchy for [" + ( *_opr ) + "]";
err = load_balanced_redirect_for_create_operation( _ctx, _opr, _curr_host, _out_parser, _out_vote );
result = ASSERT_PASS( err, err_msg );
}
else {
// =-=-=-=-=-=-=-
// must have been passed a bad operation
result = ASSERT_ERROR( false, INVALID_OPERATION, "Operation not supported: \"%s\".",
_opr->c_str() );
}
}
}
}
return result;
} // load_balanced_redirect
void Gear_Blur::runVideo()
{
_image = _VIDEO_IN->type();
ASSERT_ERROR(_image);
if (_image->isNull())
return;
_sizeY = _image->height();
_sizeX = _image->width();
_outImage = _VIDEO_OUT->type();
ASSERT_ERROR(_outImage);
_outImage->resize(_sizeX, _sizeY);
////////////////////////////
_blurSize=(int) MAX(_AMOUNT_IN->type()->value(), 0.0f);
if (_blurSize == 0)
{
// No blur, just copy image.
memcpy(_outImage->data(), _image->data(), _image->size()*sizeof(RGBA));
}
else
{
ASSERT_ERROR(_table);
// Compute the summed area table.
_table->reset((unsigned char*)_image->data(), _sizeX, _sizeY);
_outData = (unsigned char*)_outImage->data();
// Loop through the image's pixels.
for (int y=0;y<_sizeY;y++)
{
for (int x=0;x<_sizeX;x++)
{
// The kernel's coordinates.
_x1 = MAX(x - _blurSize - 1,-1);
_x2 = MIN(x + _blurSize, _sizeX-1);
_y1 = MAX(y - _blurSize - 1, -1);
_y2 = MIN(y + _blurSize, _sizeY-1);
// Get the sum in the current kernel.
_table->getSum(_sum, _area, _x1, _y1, _x2, _y2);
ASSERT_ERROR(_area >= 0);
// Take the mean and copy it to output.
divideVecVal(_outData, _sum, _area, SIZE_RGBA);
// Increment iterator.
_outData += SIZE_RGBA;
}
}
}
}
// =-=-=-=-=-=-=-
// used to allow the resource to determine which host
// should provide the requested operation
irods::error impostor_resource_redirect_plugin(
irods::resource_plugin_context& _ctx,
const std::string* _opr,
const std::string* _curr_host,
irods::hierarchy_parser* _out_parser,
float* _out_vote ) {
irods::error result = SUCCESS();
// =-=-=-=-=-=-=-
// check the context validity
irods::error ret = _ctx.valid< irods::file_object >();
if ( ( result = ASSERT_PASS( ret, "Invalid resource context." ) ).ok() ) {
// =-=-=-=-=-=-=-
// check incoming parameters
if ( ( result = ASSERT_ERROR( _opr && _curr_host && _out_parser && _out_vote, SYS_INVALID_INPUT_PARAM, "Invalid input parameter." ) ).ok() ) {
// =-=-=-=-=-=-=-
// cast down the chain to our understood object type
irods::file_object_ptr file_obj = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );
// =-=-=-=-=-=-=-
// get the name of this resource
std::string resc_name;
ret = _ctx.prop_map().get< std::string >( irods::RESOURCE_NAME, resc_name );
if ( ( result = ASSERT_PASS( ret, "Failed in get property for name." ) ).ok() ) {
// =-=-=-=-=-=-=-
// add ourselves to the hierarchy parser by default
_out_parser->add_child( resc_name );
// =-=-=-=-=-=-=-
// test the operation to determine which choices to make
if ( irods::OPEN_OPERATION == ( *_opr ) ||
irods::WRITE_OPERATION == ( *_opr ) ) {
// =-=-=-=-=-=-=-
// call redirect determination for 'get' operation
ret = impostor_resource_redirect_open( _ctx.prop_map(), file_obj, resc_name, ( *_curr_host ), ( *_out_vote ) );
result = ASSERT_PASS_MSG( ret, "Failed redirecting for open." );
}
else if ( irods::CREATE_OPERATION == ( *_opr ) ) {
// =-=-=-=-=-=-=-
// call redirect determination for 'create' operation
ret = impostor_resource_redirect_create( _ctx.prop_map(), file_obj, resc_name, ( *_curr_host ), ( *_out_vote ) );
result = ASSERT_PASS_MSG( ret, "Failed redirecting for create." );
}
else {
// =-=-=-=-=-=-=-
// must have been passed a bad operation
result = ASSERT_ERROR( false, INVALID_OPERATION, "Operation not supported." );
}
}
}
}
return result;
} // impostor_resource_redirect_plugin
//------------------------------------------------------------------------------------------
void* PoolAllocator::allocate(size_t size, size_t alignment, size_t offset,
const char* file_name, uint32 line, const char* func_name)
{
ASSERT_ERROR(mChunkSize == size, "Size of chunk does not match the expected size in pool allocator");
ASSERT_ERROR(mAlignment == alignment, "Alignment of chunk does not match the expected alignment in pool allocator");
ASSERT_ERROR(mOffset == offset, "Offset of chunk does not match the expected offset in pool allocator");
// Increment the number of allocations (Used for getTotalAllocated())
++mCount;
return mFreeList->obtainNode();
}
//-------------------------------------
// ~Load
//-------------------------------------
void XContainer::Load(const std::string &path)
{
LPD3DXBUFFER adjacency_buffer;
if (FAILED(D3DXLoadMeshFromX(
path.c_str(),
D3DXMESH_SYSTEMMEM,
DirectX9Holder::device_,
&adjacency_buffer,
&material_buffer_,
NULL,
&material_count_,
&mesh_)))
{
std::string warning;
warning = path;
warning += ": このファイルが見つかりません";
ASSERT_WARNING(warning.c_str());
ASSERT_ERROR("モデル読み込みに失敗");
return;
}
if (FAILED(mesh_->OptimizeInplace(
D3DXMESHOPT_COMPACT |
D3DXMESHOPT_ATTRSORT |
D3DXMESHOPT_VERTEXCACHE,
(DWORD*)adjacency_buffer->GetBufferPointer(),
NULL, NULL, NULL)))
{
ASSERT_ERROR("モデルのオプティマイズに失敗");
return;
}
D3DVERTEXELEMENT9 elements[] = {
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
LPD3DXMESH old_mesh = mesh_;
if (FAILED(old_mesh->CloneMesh(
D3DXMESH_MANAGED,
elements,
DirectX9Holder::device_,
&mesh_)))
{
ASSERT_ERROR("モデルのコンバートに失敗");
return;
}
SAFE_RELEASE(old_mesh);
}
void XFileDataSet::setExample(int t) {
ASSERT_ERROR( example );
ASSERT_ERROR( 0 <= t && t < nExamples);
if (t != currentExampleIndex+1) {
if (file->seek(2*sizeof(int) + t*dim*sizeof(real), SEEK_SET) != 0)
ERROR("Cannot seek to position %d.", t);
file->read(example, sizeof(real), dim);
currentExampleIndex = t;
}
}
error auth_manager::resolve(
const std::string& _key,
auth_ptr& _value ) {
error result = SUCCESS();
if ( ( result = ASSERT_ERROR( !_key.empty(), SYS_INVALID_INPUT_PARAM, "Empty plugin name." ) ).ok() ) {
if ( ( result = ASSERT_ERROR( plugins_.has_entry( _key ), SYS_INVALID_INPUT_PARAM, "No auth plugin found for name: \"%s\".",
_key.c_str() ) ).ok() ) {
_value = plugins_[_key];
}
}
return result;
}
void Gear_ListBox::onUpdateSettings()
{
_VALUE_OUT->type()->resize(_settings.get(Gear_ListBox::SETTING_NELEMS)->valueInt());
//set the value, to force clamping if needed
setValue(getValue());
//then we need to redraw the gearGui
getGearGui()->reDraw();
// XXX temporary hack to save labels, to be removed ultimately
char str[1000];
strcpy(str, _settings.get(Gear_ListBox::SETTING_LABELS)->valueStr().c_str());
char *tok = strtok(str, ",");
_labels.resize(0);
while (tok != NULL) // parse comma-separated array
{
_labels.push_back(tok);
tok = strtok (NULL, ",");
}
std::cout << "labels : " << _settings.get(Gear_ListBox::SETTING_LABELS)->valueStr() << std::endl;
std::cout << "value out type: " << _VALUE_OUT->type()->size() <<std::endl;
std::cout << "label: " << _labels.size() <<std::endl;
ASSERT_ERROR(_labels.size() == _VALUE_OUT->type()->size());
_acceptHint = false;
}
/**
* @brief Memory safe implementation of newlib's _sbrk().
*
*/
__LTO_EXT
void *_sbrk(int incr)
{
uint8_t *newheapstart;
if (heapend + incr > &__HeapLimit)
{
/* Hitting this, means that the value of _HEAP_SIZE is too small.
* The value of incr is in stored_incr at this point. By checking the equation
* above, it is straightforward to determine the missing space.
*/
volatile int stored_incr __attribute__((unused));
stored_incr = incr;
ASSERT_ERROR(0);
errno = ENOMEM;
return (void *) - 1;
}
newheapstart = heapend;
heapend += incr;
return newheapstart;
}
TEST badupdate() {
mvSession session;
mvStrArray script(2);
script.append(REQ23);
script.append(BADREQ4);
try
{
session.perform(script);
ASSERT_ERROR(((mvError*)NULL), MVERROR_SYNTAX);
}
catch (mvError* err)
{
ASSERT_ERROR(err, MVERROR_SYNTAX);
mvError_release(err);
}
}
/**
****************************************************************************************
* @brief Sets the BLE wake-up delay.
*
* @return void
****************************************************************************************
*/
void set_sleep_delay(void)
{
int16_t delay;
uint32_t sleep_delay;
delay = 0;
if (lp_clk_sel == LP_CLK_RCX20)
{
if (rcx_period > (RCX_PERIOD_MAX << 10) )
ASSERT_ERROR(0);
sleep_delay = SLP_PROC_TIME + SLEEP_PROC_TIME + (4 * RCX_PERIOD_MAX); // 400
}
else // if (lp_clk_sel == LP_CLK_XTAL32)
{
sleep_delay = /*SLP_PROC_TIME + SLEEP_PROC_TIME + */(4 * XTAL32_PERIOD_MAX); // ~200
}
// Actual "delay" is application specific and is the execution time of the BLE_WAKEUP_LP_Handler(), which depends on XTAL trimming delay.
// In case of OTP copy, this is done while the XTAL is settling. Time unit of delay is usec.
delay += XTAL_TRIMMING_TIME_USEC;
// Icrease time taking into account the time from the setting of DEEP_SLEEP_ON until the assertion of DEEP_SLEEP_STAT.
delay += sleep_delay;
// Add any application specific delay
delay += APP_SLEEP_DELAY_OFFSET;
rwip_wakeup_delay_set(delay);
}
/// =-=-=-=-=-=-=-
/// @brief get the next resource shared pointer given this resources name
/// as well as the object's hierarchy string
irods::error get_next_child_in_hier(
const std::string& _name,
const std::string& _hier,
irods::resource_child_map& _cmap,
irods::resource_ptr& _resc ) {
irods::error result = SUCCESS();
// =-=-=-=-=-=-=-
// create a parser and parse the string
irods::hierarchy_parser parse;
irods::error err = parse.set_string( _hier );
if ( ( result = ASSERT_PASS( err, "Failed in set_string" ) ).ok() ) {
// =-=-=-=-=-=-=-
// get the next resource in the series
std::string next;
err = parse.next( _name, next );
if ( ( result = ASSERT_PASS( err, "Failed in next." ) ).ok() ) {
// =-=-=-=-=-=-=-
// get the next resource from the child map
if ( ( result = ASSERT_ERROR( _cmap.has_entry( next ), CHILD_NOT_FOUND, "Child map missing entry: \"%s\"",
next.c_str() ) ).ok() ) {
// =-=-=-=-=-=-=-
// assign resource
_resc = _cmap[ next ].second;
}
}
}
return result;
} // get_next_child_in_hier
TEST(Ldd, EmptyCache)
{
vector<ldcache::Entry> cache;
Try<hashset<string>> dependencies = ldd("/bin/sh", cache);
ASSERT_ERROR(dependencies);
}
bool Schema::removeDeepGear(Gear* gear)
{
ASSERT_ERROR(gear!=NULL);
if (_locked)
{
_scheduledDeletes.push_back(gear);
return true;
}
// if the gear to be removed is at the current schema level, remove it here
if(find(_gears.begin(),_gears.end(),gear) != _gears.end())
{
onGearRemoved(gear);
_gears.remove(gear);
delete gear;
return true;
}
// otherwise, search recursively in subschemas
std::list<Schema*> subSchemas = getSubSchemas();
for(std::list<Schema*>::iterator it = subSchemas.begin();it!=subSchemas.end();++it)
if((*it)->removeDeepGear(gear))
return true;
return false;
}
void hw_aes_hash_cfg_dma(const uint8 *src, uint8 *dst, unsigned int len)
{
/* Source address setting */
AES_HASH->CRYPTO_FETCH_ADDR_REG = DA15000_phy_addr((uint32)src);
/* Destination address setting */
if (dst) {
unsigned int remap_type = REG_GETF(CRG_TOP, SYS_CTRL_REG, REMAP_ADR0);
if (IS_SYSRAM_ADDRESS(dst) ||
(IS_REMAPPED_ADDRESS(dst) && (remap_type == 0x3))) {
AES_HASH->CRYPTO_DEST_ADDR_REG = DA15000_phy_addr((uint32)dst);
#if dg_configEXEC_MODE != MODE_IS_CACHED
} else if (IS_CACHERAM_ADDRESS(dst)) {
AES_HASH->CRYPTO_DEST_ADDR_REG = DA15000_phy_addr((uint32)dst);
#endif
} else {
/*
* Destination address can only reside in RAM or Cache RAM, but in case of remapped
* address, REMAP_ADR0 cannot be 0x6 (Cache Data RAM)
*/
ASSERT_ERROR(0);
}
}
/* Data length setting */
AES_HASH->CRYPTO_LEN_REG = (uint32)len;
}
// =-=-=-=-=-=-=-
// unixStageToCache - This routine is for testing the TEST_STAGE_FILE_TYPE.
// Just copy the file from filename to cacheFilename. optionalInfo info
// is not used.
irods::error mock_archive_stagetocache_plugin(
irods::resource_plugin_context& _ctx,
const char* _cache_file_name ) {
irods::error result = SUCCESS();
// =-=-=-=-=-=-=-
// Check the operation parameters and update the physical path
irods::error ret = unix_check_params_and_path< irods::file_object >( _ctx );
if ( ( result = ASSERT_PASS( ret, "Invalid plugin context." ) ).ok() ) {
// =-=-=-=-=-=-=-
// get ref to fco
irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );
// =-=-=-=-=-=-=-
// get the vault path for the resource
std::string path;
ret = _ctx.prop_map().get< std::string >( irods::RESOURCE_PATH, path );
if ( ( result = ASSERT_PASS( ret, "Failed to retrieve vault path for resource." ) ).ok() ) {
// =-=-=-=-=-=-=-
// append the hash to the path as the new 'cache file name'
path += "/";
path += fco->physical_path().c_str();
int status = mockArchiveCopyPlugin( fco->mode(), fco->physical_path().c_str(), _cache_file_name );
result = ASSERT_ERROR( status >= 0, status, "Failed copying archive file: \"%s\" to cache file: \"%s\".",
fco->physical_path().c_str(), _cache_file_name );
}
}
return result;
} // mock_archive_stagetocache_plugin
// =-=-=-=-=-=-=-
// interface for POSIX Unlink
irods::error mock_archive_unlink_plugin(
irods::resource_plugin_context& _ctx ) {
irods::error result = SUCCESS();
// =-=-=-=-=-=-=-
// Check the operation parameters and update the physical path
irods::error ret = unix_check_params_and_path< irods::file_object >( _ctx );
if ( ( result = ASSERT_PASS( ret, "Invalid plugin context." ) ).ok() ) {
// =-=-=-=-=-=-=-
// get ref to fco
irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );
// =-=-=-=-=-=-=-
// make the call to unlink
int status = unlink( fco->physical_path().c_str() );
// =-=-=-=-=-=-=-
// error handling
int err_status = UNIX_FILE_UNLINK_ERR - errno;
result = ASSERT_ERROR( status >= 0, err_status, "Unlink error for: \"%s\", errno = \"%s\", status = %d.",
fco->physical_path().c_str(), strerror( errno ), err_status );
}
return result;
} // mock_archive_unlink_plugin
// =-=-=-=-=-=-=-
//@brief Recursively make all of the dirs in the path
irods::error mock_archive_mkdir_r(
const std::string& path,
mode_t mode ) {
irods::error result = SUCCESS();
std::string subdir;
std::size_t pos = 0;
bool done = false;
while ( !done && result.ok() ) {
pos = path.find_first_of( '/', pos + 1 );
if ( pos > 0 ) {
subdir = path.substr( 0, pos );
int status = mkdir( subdir.c_str(), mode );
// =-=-=-=-=-=-=-
// handle error cases
result = ASSERT_ERROR( status >= 0 || errno == EEXIST, UNIX_FILE_RENAME_ERR - errno, "mkdir error for \"%s\", errno = \"%s\", status = %d.",
subdir.c_str(), strerror( errno ), status );
}
if ( pos == std::string::npos ) {
done = true;
}
}
return result;
} // mock_archive_mkdir_r
//-------------------------------------
// ObjectFactory()
//-------------------------------------
Object *ObjectFactory::Create(
const OBJECT_PARAMETER_DESC ¶meter)
{
// 変数宣言
OBJECT_PARAMETER_DESC param = parameter;
Object *object = nullptr;
switch (param.layer_)
{
case LAYER_SPRITE_LAKE:
object = new Lake(parameter);
break;
case LAYER_MODEL_GRANDFATHER:
object = new FbxGrandfather(parameter);
break;
case LAYER_MODEL_CHILD:
object = new FbxChild(parameter);
break;
case LAYER_BULLET:
object = new Bullet(parameter);
break;
case LAYER_BOMB:
object = new Bomb(parameter);
break;
case LAYER_TREE:
object = new InstancingTree(parameter);
break;
case LAYER_BENCH:
object = new InstancingBench(parameter);
break;
case LAYER_PLAYGROUND:
object = new InstancingPlayground(parameter);
break;
case LAYER_SHADOW:
object = new Shadow(parameter);
break;
case LAYER_DAMAGE_EFFECT:
object = new DamageEffect(parameter);
break;
case LAYER_TIMER:
object = new Timer(parameter);
break;
case LAYER_SPRITE_2D:
object = new Sprite2D(parameter);
break;
case LAYER_FORT_GAUGE:
break;
case LAYER_COUNTDOWN:
object = new CountDown(parameter);
break;
case LAYER_BLIND:
object = new Blind(parameter);
break;
default:
ASSERT_ERROR("無効なオブジェクト生成カテゴリです");
break;
}
return object;
}
//-------------------------------------------------------------------------------------------
PoolAllocator::~PoolAllocator()
{
ASSERT_ERROR(mCount == 0, "Pool allocator has memory leaks");
// Destroy the free list and deallocate the memory
mFreeList->~FreeList();
mAllocator->deallocate(static_cast<void*>(mStart));
mFreeList = nullptr;
}
TupleDataSet::TupleDataSet(XFile* file_, unsigned int observationDim_, ActionProperties* actionProperties_)
: DataSet(0, 2*observationDim_ + actionProperties_->dim() + 1),
file(file_),
lastObservation(observationDim_),
lastAction(actionProperties_),
observation(observationDim_) {
ASSERT_ERROR( file );
}
//------------------------------------------------------------------------------------------
LinearAllocator::~LinearAllocator()
{
ASSERT_ERROR(getTotalAllocated() == 0, "Linear allocator has memory leaks");
if (mStart)
{
SysAlloc::releaseSegment(static_cast<void*>(mStart), mSize);
mStart = mCurrent = nullptr;
}
}
TEST(Ldd, MissingFile)
{
Try<vector<ldcache::Entry>> cache = ldcache::parse();
ASSERT_SOME(cache);
Try<hashset<string>> dependencies =
ldd("/this/path/is/not/here", cache.get());
ASSERT_ERROR(dependencies);
}
//------------------------------------------------------------------------------------------
void PoolAllocator::deallocate(void* ptr)
{
if (ptr)
{
ASSERT_ERROR(ptr > mStart && ptr < (mStart + mSize), "Chunk returned does not belong to this pool");
// Decrement the number of allocations (Used for getTotalAllocated())
--mCount;
mFreeList->returnNode(ptr);
}
}
Property* Properties::add(Property::eType type, std::string name)
{
//no duplicate
ASSERT_ERROR(_properties.find(name) == _properties.end());
Property *newProperty = new Property(type, name);
_properties[name] = newProperty;
return newProperty;
}
//-------------------------------------
// Get()
//-------------------------------------
MyEffect *EffectManager::Get(
const std::string &name)
{
for (auto it = effects_.begin(); it != effects_.end(); ++it){
if ((*it).first == name){
return (*it).second;
}
}
ASSERT_ERROR("指定した名前のエフェクトは存在しません");
return nullptr;
}
// test error cases
void
testError (void)
{
BM_BufferPool *bm = MAKE_POOL();
BM_PageHandle *h = MAKE_PAGE_HANDLE();
testName = "ERROR TEST";
CHECK(createPageFile("testbuffer.bin"));
// pinpage until buffer pool is full and then request additional page.
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
CHECK(pinPage(bm, h, 0));
CHECK(pinPage(bm, h, 1));
CHECK(pinPage(bm, h, 2));
ASSERT_ERROR(pinPage(bm, h, 3), "try to pin page when pool is full of pinned pages with fix-count > 0");
CHECK(shutdownBufferPool(bm));
// try to pin page with negative page number.
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
ASSERT_ERROR(pinPage(bm, h, -10), "try to pin page with negative page number");
CHECK(shutdownBufferPool(bm));
// try to use uninitialized buffer pool
ASSERT_ERROR(initBufferPool(bm, "unavailable.bin", 3, RS_FIFO, NULL), "try to init buffer pool for non existing page file");
ASSERT_ERROR(shutdownBufferPool(bm), "shutdown buffer pool that is not open");
ASSERT_ERROR(forceFlushPool(bm), "flush buffer pool that is not open");
ASSERT_ERROR(pinPage(bm, h, 1), "pin page in buffer pool that is not open");
// try to unpin, mark, or force page that is not in pool
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
ASSERT_ERROR(unpinPage(bm, h), "Try to unpin a page which is not available in framelist.");
ASSERT_ERROR(forcePage(bm, h), "Try to forceflush a page which is not available in framelist.");
ASSERT_ERROR(markDirty(bm, h), "Try to markdirty a page which is not available in framelist.");
CHECK(shutdownBufferPool(bm));
// done remove page file
CHECK(destroyPageFile("testbuffer.bin"));
free(bm);
free(h);
TEST_DONE();
}
// test error cases
void
testError (void)
{
int i;
BM_BufferPool *bm = MAKE_POOL();
BM_PageHandle *h = MAKE_PAGE_HANDLE();
testName = "Testing LRU page replacement";
CHECK(createPageFile("testbuffer.bin"));
// pin until buffer pool is full and request additional page
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
CHECK(pinPage(bm, h, 0));
CHECK(pinPage(bm, h, 1));
CHECK(pinPage(bm, h, 2));
ASSERT_ERROR(pinPage(bm, h, 3), "try to pin page when pool is full of pinned pages");
CHECK(shutdownBufferPool(bm));
// try to ready page with negative page number
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
ASSERT_ERROR(pinPage(bm, h, -1), "try to pin page with negative page number");
CHECK(shutdownBufferPool(bm));
// try to use uninitialized buffer pool
ASSERT_ERROR(shutdownBufferPool(bm), "shutdown buffer pool that is not open");
ASSERT_ERROR(forceFlushPool(bm), "flush buffer pool that is not open");
ASSERT_ERROR(pinPage(bm, h, 1), "pin page in buffer pool that is not open");
ASSERT_ERROR(initBufferPool(bm, "xxx.bin", 3, RS_FIFO, NULL), "try to init buffer pool for non existing page file");
// try to unpin, mark, or force page that is not in pool
CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL));
ASSERT_ERROR(unpinPage(bm, h), "unpin page not in buffer pool");
ASSERT_ERROR(forcePage(bm, h), "unpin page not in buffer pool");
ASSERT_ERROR(markDirty(bm, h), "mark page dirty that is not in buffer pool");
CHECK(shutdownBufferPool(bm));
// done remove page file
CHECK(destroyPageFile("testbuffer.bin"));
free(bm);
free(h);
TEST_DONE();
}