void test_f_InfoClientes() { ParqueEstacionamento p1(10,20); p1.novo_cliente("Joao Santos"); p1.novo_cliente("Pedro Morais"); p1.novo_cliente("Rui Silva"); p1.novo_cliente("Susana Costa"); p1.novo_cliente("Maria Tavares"); p1.entrar("Maria Tavares"); p1.entrar("Susana Costa"); p1.sair("Susana Costa"); p1.entrar("Rui Silva"); p1.entrar("Susana Costa"); ASSERTM("Este teste nunca falha! VERIFICAR informação escrita no monitor", true); cout << p1; InfoCartao ic=p1.get_cliente_pos(2); ASSERT_EQUAL("Rui Silva", ic.nome); ASSERT_THROWS(p1.get_cliente_pos(6), PosicaoNaoExistente); try { p1.get_cliente_pos(6); } catch (PosicaoNaoExistente &e) { ASSERTM("Este teste nunca falha. Verifique no monitor a informação", true); cout << "Apanhou excepção. Posição não existente:" << e.getValor() << endl; ASSERT_EQUAL(6, e.getValor()); } }
void database_testUpgrade() { const char* dbname="/tmp/dbtest.db"; createVersion4db(dbname); Database db("/tmp/dbtest.db"); shared_ptr<ITaskAccessor> taskAccessor=db.getTaskAccessor(); ASSERT_EQUALM("Numbers of tasks in tasks", 2, taskAccessor->getTasksChangedSince()->size()); shared_ptr<Task> task1 = taskAccessor->getTask(1); ASSERT_EQUALM("Task 1 name ", string("Test"),task1->getName()); ASSERT_EQUALM("Task 1 parent ", 0, task1->getParentID()); ASSERTM("Task 1 uuid is valid ", UUID::isValid(task1->getUUID())); shared_ptr<Task> task2 = taskAccessor->getTask(2); ASSERT_EQUALM("Task 2 name ", string("Sub task"),task2->getName()); ASSERT_EQUALM("Task 2 parent ", 1, task2->getParentID()); ASSERTM("Task 2 uuid is valid ", UUID::isValid(task2->getUUID())); shared_ptr<ITimeAccessor> timeAccessor=db.getTimeAccessor(); shared_ptr<vector<TimeEntry>> times=timeAccessor->getTimesChangedSince(); ASSERT_EQUALM("Number of times ",1, times->size()); TimeEntry te = times->at(0); ASSERT_EQUALM("Time id ", 1, te.getID()); ASSERTM("Time uuid is valid ", UUID::isValid(te.getUUID())); ASSERT_EQUALM("Time taskID ", 2, te.getTaskID()); ASSERT_EQUALM("Time start ", 10, te.getStart()); ASSERT_EQUALM("Time stop ", 100, te.getStop()); OSAbstraction::unlink("/tmp/dbtest.db"); }
/*---------------------------------------------------------------------*//** GUI の作成実装 **//*---------------------------------------------------------------------*/ EtkGui* AtArBody::makeGui() { // 固定データの初期化 if(!AtArFixedData::init()) { ASSERTM(false, "FixedData::init failed."); return 0L; } // フォントセットの作成 AtArFontSet* fontset = new AtArFontSet(); if(!fontset->create()) { delete fontset; ASSERTM(false, "GameFontSet::create failed."); return 0L; } _fontset = fontset; // GUI の作成 AtArGui* gui = new AtArGui(); if(!gui->create(_fontset, _tasksys)) { delete gui; ASSERTM(false, "GameGui::create failed."); return 0L; } return gui; }
void specifyVar(uint u_varIndex, volatile void* pv_data, uint u_size, BOOL b_isWriteable, char* psz_format, char* psz_name, char* psz_desc) { uint u_len; // Make sure this variable exists ASSERTM("specifyVar:indexTooHigh", u_varIndex < NUM_XFER_VARS); // Make sure the data isn't NULL ASSERTM("specifyVar:nullData", pv_data != NULL); // Make sure the size is valid ASSERTM("specifyVar:invalidSize", (u_size > 0) && (u_size <= 256)); // Update data structure xferVar[u_varIndex].pu8_data = (uint8_t*) pv_data; xferVar[u_varIndex].u8_size = u_size - 1; assignBit(u_varIndex, b_isWriteable); // Send a command OUT_CHAR(CMD_TOKEN); // Send a specification: The spec code, index, then length outCharXfer(b_isWriteable ? CMD_SEND_RECEIVE_VAR : CMD_SEND_ONLY); outCharXfer(u_varIndex); // Include the space taken by the three NULL characters, minus one since a // length of 1 is sent as 0, plus one for the variable size byte. u_len = strlen(psz_format) + strlen(psz_name) + strlen(psz_desc) + 3 - 1 + 1; // Allow a maximum string length of 255. outCharXfer(u_len <= 255 ? u_len : 255); // Send the size of this variable, minus 1 since a size of 1 is sent as a 0. outCharXfer(u_size - 1); // Send the strings u_len = 1; do { if (u_len++ > 256) return; outCharXfer(*psz_format); } while (*psz_format++); do { if (u_len++ > 256) return; outCharXfer(*psz_name); } while (*psz_name++); do { if (u_len++ > 256) return; outCharXfer(*psz_desc); } while (*psz_desc++); }
static void testLogicOperators() { float x=10.1,y=23.5,z=13.54; Z3D_Base::Vector3f temp(x,y,z), temp1(x,y,z); ASSERTM("Test failed for vector3f in operator arithematic(vector): x==y", (Z3D_Base::Vector3f)temp==(Z3D_Base::Vector3f)temp1); }
void ConfigEntryTest::testGetIntegerFormattedOptions() { std::string entr_str = "command option1=1 option2=2 option3=3"; ConfigEntry conf_entry(entr_str); std::map<std::string, int> intmap = conf_entry.getIntegerFormattedOptions(); // forall in intmap { std::map<std::string, int>::const_iterator it_intmap = intmap.begin(); const std::map<std::string, int>::const_iterator it_intmap_end = intmap.end(); while (it_intmap != it_intmap_end) { std::string opt = it_intmap->first; int val = it_intmap->second; if (opt == "option1") { ASSERT_EQUAL(1, val); } else if (opt == "option2") { ASSERT_EQUAL(2, val); } else if (opt == "option3") { ASSERT_EQUAL(3, val); } else { std::cout << "ConfigEntryTest::testGetIntegerFormattedOptions: " << "'" << opt << "'" << ":" << "'" << val << "'" << std::endl; ASSERTM("Unknown option!", false); } ++it_intmap; } } }
void multiplyTest() { Calculate calc; int first = 5; int second = 5; ASSERTM("Multiplication was incorrect!", 25 == calc.multiply(first, second)); }
void subTest() { Calculate calc; int first = 5; int second = 3; ASSERTM("Subtraction was incorrect!", 2 == calc.sub(first, second)); }
void TimeEntry_setDeleted() { TimeEntry te=getTestTimeEntry(); time_t now=time(0); te.setDeleted(true); ASSERT_EQUAL(true, te.getDeleted()); ASSERTM("Changed time should be at current time", te.getLastChanged()>=now); }
void TimeEntry_changeEndTime() { TimeEntry te=getTestTimeEntry(); time_t now=time(0); te.setStop(2000); ASSERT_EQUAL(2000, te.getStop()); ASSERTM("Changed time should be at current time", te.getLastChanged()>=now); }
void sumTest() { Calculate calc; int first = 5; int second = 5; ASSERTM("Summation was incorrect!", 10 == calc.sum(first, second)); }
void Assertion::ASSERT_ANY_COMPARE(const ROAnything &inputAny, const ROAnything &masterAny, String location, char delimSlot, char idxdelim) { OStringStream s; String failingPath(location); if(!AnyUtils::AnyCompareEqual(inputAny, masterAny, failingPath,&s, delimSlot, idxdelim)) { String strfail(failingPath); strfail << "\n" << s.str(); ASSERTM((const char*)strfail, false); } }
void testValidInput() { char user_input[20] = {'1','2','3','4'}; char good_input[20] = {'1','2','3','4'}; int i = 0; while(user_input[i] != '\0' && user_input[i] != '\n' && i<20) { ASSERTM("Failed Valid Input Test", validateSelection(user_input[i],good_input)); i++; } }
// Must define void operator() with no arguments void IXMLWriterTest::operator()() { writeXMLHeader(); writeElement(); writeComment(); writeClosingTag(); writeText(); writeLineBreak(); ASSERTM(mes.c_str(), mes.size() == 0); }
/*---------------------------------------------------------------------*//** テストモジュールの作成実装 **//*---------------------------------------------------------------------*/ Test* AtArBody::makeTest(f32 spfRender, f32 spfLogic) { Test* test = new AtArTest(); if(!test->create(spfRender, spfLogic)) { delete test; ASSERTM(false, "Test::create failed."); return 0L; } return test; }
void testSpecialCharacters() { char user_input[4] = {'@', '!', '%', '$'}; char good_input[20] = {'1','2','3', 'a', 'b', 's'}; int i = 0; while ((user_input[i] != '\0') && (user_input[i] != '\n') && i<4) { ASSERTM("Failed Special Character Test", !validateSelection(user_input[i],good_input)); i++; } }
/*---------------------------------------------------------------------*//** アクションメッセージウインドウの作成実装 **//*---------------------------------------------------------------------*/ ActionMsgWindow* DimzGui::makeActionMsgWindow() { // アクションメッセージウインドウを作成する ActionMsgWindow* wndActMsg = new ActionMsgWindow(); if(!wndActMsg->create(_fontsetRef->getMainGuiFont(), _texGui)) { delete wndActMsg; ASSERTM(false, "GameActMsgWindow::create failed."); return false; } return wndActMsg; }
void testOutOfRange() { char user_input[3] = {'0', '5', '6'}; char good_input[20] = {'1','2','3','4'}; int i = 0; while ((user_input[i] != '\0') && (user_input[i] != '\n') && i<3) { //printf("Input tested: %s\n", user_input[i]); ASSERTM("Failed Out of Range Test", !validateSelection(user_input[i],good_input)); i++; } }
void sendVar(uint u_varIndex) { XFER_VAR* pXferVar; uint8_t u8_size; uint8_t* pu8_data; // Make sure this variable exists ASSERTM("sendVar:indexTooHigh", u_varIndex < NUM_XFER_VARS); // Note: The MS C compiler flags the statement // XFER_VAR* pXferVar = xferVar + u_varIndex; // as an error. It's OK in MS C++. Apparently, the C compiler doesn't // support the newer C99 syntax. Therefore, u8_size and pu8_data are // also declared above. pXferVar = xferVar + u_varIndex; ASSERTM("sendVar:indexNotSpecified", pXferVar->pu8_data != NULL); // Make sure it's read/write (PC only) #ifndef __PIC__ ASSERTM("sendVar:notWriteable", isVarWriteable(u_varIndex)); #endif // Send a command OUT_CHAR(CMD_TOKEN); // Send short/long var info u8_size = pXferVar->u8_size; if ((u8_size + 1) > SHORT_VAR_MAX_LEN) { // Send a long var: The long var code, index, then length outCharXfer(CMD_LONG_VAR); outCharXfer(u_varIndex); outCharXfer(u8_size); } else { // Send a short var outCharXfer((u_varIndex << VAR_SIZE_BITS) | u8_size); } // Send data pu8_data = pXferVar->pu8_data; do { outCharXfer(*pu8_data++); } while (u8_size--); }
void test_g_InfoFrota() { Veiculo *v1 =new Automovel("Fiat",5,1997,"gasolina",1200); Veiculo *v2= new Camiao("Ford",3,1999,"gasolina",1400,1000); Veiculo *v3=new Bicicleta("XX",4,2002,"TodoTerreno"); Frota f; f.adicionaVeiculo(v1); f.adicionaVeiculo(v2); f.adicionaVeiculo(v3); ASSERTM("Este teste nunca falha! VERIFICAR informação escrita no monitor", true); f.info(); }
int formatVar(uint u_varIndex, char* psz_buf) { XFER_VAR* pXferVar; uint8_t u8_size; unsigned long long ull_buf = 0; // The biggest data type available // Make sure this variable exists ASSERTM("formatVar:indexTooHigh", u_varIndex < NUM_XFER_VARS); // Note: The MS C compiler flags the statement // XFER_VAR* pXferVar = xferVar + u_varIndex; // as an error. It's OK in MS C++. Apparently, the C compiler doesn't // support the newer C99 syntax. Therefore, u8_size and pu8_data are // also declared above. pXferVar = xferVar + u_varIndex; ASSERTM("formatVar:indexNotSpecified", pXferVar->pu8_data != NULL); u8_size = pXferVar->u8_size + 1; // Copy the data over to the largest available var for formatting ASSERT(u8_size <= sizeof(ull_buf)); memcpy(&ull_buf, pXferVar->pu8_data, u8_size); return sprintf(psz_buf, pXferVar->psz_format, ull_buf); }
SRCR_BEGIN_NS //////////////////////////////////////////////////////////////////////////// // クラス //========================================================================== // Flag メソッド /*---------------------------------------------------------------------*//** XML 要素から読み込む **//*---------------------------------------------------------------------*/ bool Flag::analyze(ActMatter* owner, const XmlNode* node, const EventMatterCreateParam* emcp) { if(!Act::analyze(owner, node, emcp)) { return false; } s32 iwk; // [オプション(いずれか必須)]表示か非表示か if(XmlParserUtils::analyzeAtrb(&iwk, node, "sfid")) { _sfid = iwk; } // [オプション(いずれか必須)]クエスト汎用値識別番号(クエスト用) if(XmlParserUtils::analyzeAtrb(&iwk, node, "quest_gval")) { _questgval = iwk; } // [オプション]新しい値 if(XmlParserUtils::analyzeAtrb(&iwk, node, "value")) { _value = iwk; } // スキップ確認 // ※ この Act はスキップすると致命的なバグになりかねないので、 // デフォルトでは、スキップを防止すべきと考える ASSERTM(TFW_IS_FLAG(_flags, F_NOSKIP | F_SKIPONLY | F_SKIPSTOP), "{Flag::analyze} Illegal skip-flag setting of Flag-Act."); if(!TFW_IS_FLAG(_flags, F_NOSKIP | F_SKIPONLY | F_SKIPSTOP)) { TFW_SET_FLAG(_flags, F_NOSKIP, true); } return true; }
/*---------------------------------------------------------------------*//** 言語変更通知 **//*---------------------------------------------------------------------*/ void DimzGui::notifyChangeLanguage() { // 親へ通知 EtkGui::notifyChangeLanguage(); // GUI テクスチャの再読み込み if(_texGui != 0L) { _texGui->destroy(); if(!_texGui->create(FILEID_CONV_LANG( FILEID_CONV_RD( SYSTEM_GUI01_SD_EN_PNG ) ), Texture::FMT_PNG)) { ASSERTM(false, "{notifyChangeLanguage} DimzGui Texture - create failed."); } } }
/*---------------------------------------------------------------------*//** 初期化 **//*---------------------------------------------------------------------*/ bool DimzBody::init(s32 widthView, s32 heightView, f32 scaleContent, TfwRightAngle rotz, f32 spfRender, f32 spfLogic, LangId langidDefault, StartBodyCase sbcase, u32 bcflags, OsDepMod* osdep, PsnsBase* psns) { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // 基本設定 #if defined(_DEBUG) && defined(_WINDOWS) && IS_WINDOWS_IDFILE_DEVMODE_UNPACK IdFile::enableDevMode(g_filedefTbfPack, ""); #endif // 親クラス(ツールキット)による初期化 if(!EtkBody::init(widthView, heightView, scaleContent, rotz, spfRender, spfLogic, langidDefault, sbcase, bcflags, osdep, psns)) { return false; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // 各ゲームモジュールの初期化 #if 0 // ソウマ スクリプトを作成する SoumaScript* script = new SoumaScript(); if(!script->create()) { delete script; ASSERTM(false, "SoumaScript::create failed."); return false; } _script = script; #endif // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // ゲームシステムの開始 #if DEBUG_FULLMODE debug_onDebugMode(999); #endif // フェードイン if(_screffScn != 0L) { ColorU8 colBlack(0, 0, 0, 255); _screffScn->setColor1(&colBlack); _screffScn->setMaxFrame(30); _screffScn->start(ScreenEffect::MODE_FADE_IN); } return true; }
/*---------------------------------------------------------------------*//** パーティクルシステムの作成実装 **//*---------------------------------------------------------------------*/ ParticleSys* AtArBody::makeParticleSys() { const ParticleDefTbl* ptcldftbl = AtArFixedData::getParticleDefTable(); etk::SorSgm* sg = (etk::SorSgm*)getSceneGraphManager(); SgNodeChain* sgnc = sg->getKindChain(etk::SorSgm::EK_ZSORT); ParticleSys* ptclsys = new AtArParticleSys(); if(!ptclsys->create(ptcldftbl, sgnc)) { delete ptclsys; ASSERTM(false, "ParticleSys::create failed."); return false; } return ptclsys; }
/*---------------------------------------------------------------------*//** システムメッセージウインドウの作成実装 **//*---------------------------------------------------------------------*/ SysMsgWindow* DimzGui::makeSysMsgWindow() { // システムメッセージウインドウを作成する SysMsgWindow* wndSysMsg = new SysMsgWindow(); if(!wndSysMsg->create( _fontsetRef->getMainGuiFont(), _texGui, DimzFixedStrTbl::getString(DimzFixedStrTbl::SID_YES), DimzFixedStrTbl::getString(DimzFixedStrTbl::SID_NO) )) { delete wndSysMsg; ASSERTM(false, "GameSysMsgWindow::create failed."); return false; } return wndSysMsg; }
/*---------------------------------------------------------------------*//** 作成 **//*---------------------------------------------------------------------*/ bool DimzGui::create(FontSet* fontsetRef, FedTaskSys* tasksys) { // GUI テクスチャの読み込み Texture* texGui = new Texture(); if(!texGui->create(FILEID_CONV_LANG( FILEID_CONV_RD( SYSTEM_GUI01_SD_EN_PNG ) ), Texture::FMT_PNG)) { delete texGui; ASSERTM(false, "gui Texture::create failed."); return false; } _texGui = texGui; // 親の作成 if(!EtkGui::create(fontsetRef, tasksys)) { return false; } return true; }
void SimpleCollectionTest::testGetValueAt() { SimpleCollection<int> sc; sc.add(1); sc.add(2); sc.add(3); int first = sc[0]; int last = sc[2]; ASSERT_EQUAL(1, first); ASSERT_EQUAL(3, last); // test exception try { int none = sc[4]; // add this to make use of pedantic int std::cout<<"SimpleCollectionTest::testGetValueAt: "<<"sc[4]="<<none<<std::endl; ASSERTM("Exception missed!", false); } catch (exceptions::IndexOutOfBoundsException & except) { ASSERT(true); } }
REGPARM1 GNUC_ATTR_HOT void evacuate(StgClosure **p) { bdescr *bd = NULL; nat gen_no; StgClosure *q; const StgInfoTable *info; StgWord tag; q = *p; loop: /* The tag and the pointer are split, to be merged after evacing */ tag = GET_CLOSURE_TAG(q); q = UNTAG_CLOSURE(q); ASSERTM(LOOKS_LIKE_CLOSURE_PTR(q), "invalid closure, info=%p", q->header.info); if (!HEAP_ALLOCED_GC(q)) { if (!major_gc) return; info = get_itbl(q); switch (info->type) { case THUNK_STATIC: if (info->srt_bitmap != 0) { evacuate_static_object(THUNK_STATIC_LINK((StgClosure *)q), q); } return; case FUN_STATIC: if (info->srt_bitmap != 0) { evacuate_static_object(FUN_STATIC_LINK((StgClosure *)q), q); } return; case IND_STATIC: /* If q->saved_info != NULL, then it's a revertible CAF - it'll be * on the CAF list, so don't do anything with it here (we'll * scavenge it later). */ evacuate_static_object(IND_STATIC_LINK((StgClosure *)q), q); return; case CONSTR_STATIC: evacuate_static_object(STATIC_LINK(info,(StgClosure *)q), q); return; case CONSTR_NOCAF_STATIC: /* no need to put these on the static linked list, they don't need * to be scavenged. */ return; default: barf("evacuate(static): strange closure type %d", (int)(info->type)); } } bd = Bdescr((P_)q); if ((bd->flags & (BF_LARGE | BF_MARKED | BF_EVACUATED)) != 0) { // pointer into to-space: just return it. It might be a pointer // into a generation that we aren't collecting (> N), or it // might just be a pointer into to-space. The latter doesn't // happen often, but allowing it makes certain things a bit // easier; e.g. scavenging an object is idempotent, so it's OK to // have an object on the mutable list multiple times. if (bd->flags & BF_EVACUATED) { // We aren't copying this object, so we have to check // whether it is already in the target generation. (this is // the write barrier). if (bd->gen_no < gct->evac_gen_no) { gct->failed_to_evac = rtsTrue; TICK_GC_FAILED_PROMOTION(); } return; } /* evacuate large objects by re-linking them onto a different list. */ if (bd->flags & BF_LARGE) { evacuate_large((P_)q); return; } /* If the object is in a gen that we're compacting, then we * need to use an alternative evacuate procedure. */ if (!is_marked((P_)q,bd)) { mark((P_)q,bd); push_mark_stack((P_)q); } return; } gen_no = bd->dest_no; info = q->header.info; if (IS_FORWARDING_PTR(info)) { /* Already evacuated, just return the forwarding address. * HOWEVER: if the requested destination generation (gct->evac_gen) is * older than the actual generation (because the object was * already evacuated to a younger generation) then we have to * set the gct->failed_to_evac flag to indicate that we couldn't * manage to promote the object to the desired generation. */ /* * Optimisation: the check is fairly expensive, but we can often * shortcut it if either the required generation is 0, or the * current object (the EVACUATED) is in a high enough generation. * We know that an EVACUATED always points to an object in the * same or an older generation. gen is the lowest generation that the * current object would be evacuated to, so we only do the full * check if gen is too low. */ StgClosure *e = (StgClosure*)UN_FORWARDING_PTR(info); *p = TAG_CLOSURE(tag,e); if (gen_no < gct->evac_gen_no) { // optimisation if (Bdescr((P_)e)->gen_no < gct->evac_gen_no) { gct->failed_to_evac = rtsTrue; TICK_GC_FAILED_PROMOTION(); } } return; } switch (INFO_PTR_TO_STRUCT(info)->type) { case WHITEHOLE: goto loop; // For ints and chars of low value, save space by replacing references to // these with closures with references to common, shared ones in the RTS. // // * Except when compiling into Windows DLLs which don't support cross-package // data references very well. // case CONSTR_0_1: { #if defined(COMPILING_WINDOWS_DLL) copy_tag_nolock(p,info,q,sizeofW(StgHeader)+1,gen_no,tag); #else StgWord w = (StgWord)q->payload[0]; if (info == Czh_con_info && // unsigned, so always true: (StgChar)w >= MIN_CHARLIKE && (StgChar)w <= MAX_CHARLIKE) { *p = TAG_CLOSURE(tag, (StgClosure *)CHARLIKE_CLOSURE((StgChar)w) ); } else if (info == Izh_con_info && (StgInt)w >= MIN_INTLIKE && (StgInt)w <= MAX_INTLIKE) { *p = TAG_CLOSURE(tag, (StgClosure *)INTLIKE_CLOSURE((StgInt)w) ); } else { copy_tag_nolock(p,info,q,sizeofW(StgHeader)+1,gen_no,tag); } #endif return; } case FUN_0_1: case FUN_1_0: case CONSTR_1_0: copy_tag_nolock(p,info,q,sizeofW(StgHeader)+1,gen_no,tag); return; case THUNK_1_0: case THUNK_0_1: copy(p,info,q,sizeofW(StgThunk)+1,gen_no); return; case THUNK_1_1: case THUNK_2_0: case THUNK_0_2: #ifdef NO_PROMOTE_THUNKS #error bitrotted #endif copy(p,info,q,sizeofW(StgThunk)+2,gen_no); return; case FUN_1_1: case FUN_2_0: case FUN_0_2: case CONSTR_1_1: case CONSTR_2_0: copy_tag_nolock(p,info,q,sizeofW(StgHeader)+2,gen_no,tag); return; case CONSTR_0_2: copy_tag_nolock(p,info,q,sizeofW(StgHeader)+2,gen_no,tag); return; case THUNK: copy(p,info,q,thunk_sizeW_fromITBL(INFO_PTR_TO_STRUCT(info)),gen_no); return; case FUN: case CONSTR: copy_tag_nolock(p,info,q,sizeW_fromITBL(INFO_PTR_TO_STRUCT(info)),gen_no,tag); return; case BLACKHOLE: { StgClosure *r; const StgInfoTable *i; r = ((StgInd*)q)->indirectee; if (GET_CLOSURE_TAG(r) == 0) { i = r->header.info; if (IS_FORWARDING_PTR(i)) { r = (StgClosure *)UN_FORWARDING_PTR(i); i = r->header.info; } if (i == &stg_TSO_info || i == &stg_WHITEHOLE_info || i == &stg_BLOCKING_QUEUE_CLEAN_info || i == &stg_BLOCKING_QUEUE_DIRTY_info) { copy(p,info,q,sizeofW(StgInd),gen_no); return; } ASSERT(i != &stg_IND_info); } q = r; *p = r; goto loop; } case MUT_VAR_CLEAN: case MUT_VAR_DIRTY: case MVAR_CLEAN: case MVAR_DIRTY: case TVAR: case BLOCKING_QUEUE: case WEAK: case PRIM: case MUT_PRIM: copy(p,info,q,sizeW_fromITBL(INFO_PTR_TO_STRUCT(info)),gen_no); return; case BCO: copy(p,info,q,bco_sizeW((StgBCO *)q),gen_no); return; case THUNK_SELECTOR: eval_thunk_selector(p, (StgSelector *)q, rtsTrue); return; case IND: // follow chains of indirections, don't evacuate them q = ((StgInd*)q)->indirectee; *p = q; goto loop; case RET_BCO: case RET_SMALL: case RET_BIG: case UPDATE_FRAME: case UNDERFLOW_FRAME: case STOP_FRAME: case CATCH_FRAME: case CATCH_STM_FRAME: case CATCH_RETRY_FRAME: case ATOMICALLY_FRAME: // shouldn't see these barf("evacuate: stack frame at %p\n", q); case PAP: copy(p,info,q,pap_sizeW((StgPAP*)q),gen_no); return; case AP: copy(p,info,q,ap_sizeW((StgAP*)q),gen_no); return; case AP_STACK: copy(p,info,q,ap_stack_sizeW((StgAP_STACK*)q),gen_no); return; case ARR_WORDS: // just copy the block copy(p,info,q,arr_words_sizeW((StgArrBytes *)q),gen_no); return; case MUT_ARR_PTRS_CLEAN: case MUT_ARR_PTRS_DIRTY: case MUT_ARR_PTRS_FROZEN: case MUT_ARR_PTRS_FROZEN0: // just copy the block copy(p,info,q,mut_arr_ptrs_sizeW((StgMutArrPtrs *)q),gen_no); return; case SMALL_MUT_ARR_PTRS_CLEAN: case SMALL_MUT_ARR_PTRS_DIRTY: case SMALL_MUT_ARR_PTRS_FROZEN: case SMALL_MUT_ARR_PTRS_FROZEN0: // just copy the block copy(p,info,q,small_mut_arr_ptrs_sizeW((StgSmallMutArrPtrs *)q),gen_no); return; case TSO: copy(p,info,q,sizeofW(StgTSO),gen_no); return; case STACK: { StgStack *stack = (StgStack *)q; /* To evacuate a small STACK, we need to adjust the stack pointer */ { StgStack *new_stack; StgPtr r, s; rtsBool mine; mine = copyPart(p,(StgClosure *)stack, stack_sizeW(stack), sizeofW(StgStack), gen_no); if (mine) { new_stack = (StgStack *)*p; move_STACK(stack, new_stack); for (r = stack->sp, s = new_stack->sp; r < stack->stack + stack->stack_size;) { *s++ = *r++; } } return; } } case TREC_CHUNK: copy(p,info,q,sizeofW(StgTRecChunk),gen_no); return; default: barf("evacuate: strange closure type %d", (int)(INFO_PTR_TO_STRUCT(info)->type)); } barf("evacuate"); }
void thisIsATest() { ASSERTM("start writing tests", false); }