TEST(WireFormat, StructRoundTrip_OneSegment) { Session ctx; setupStruct(&ctx.capn); // word count: // 1 root reference // 8 root struct // 1 sub message // 2 3-element int32 list // 13 struct list // 1 tag // 12 4x struct // 1 data segment // 1 reference segment // 1 sub-struct // 11 list list // 5 references to sub-lists // 6 sub-lists (4x 1 word, 1x 2 words) // 2 recurse // ----- // 38 ASSERT_EQ(1, ctx.capn.segnum); EXPECT_EQ(38*8, ctx.capn.seglist->len); checkStruct(&ctx.capn); struct capn ctx2; memset(&ctx2, 0, sizeof(ctx2)); capn_append_segment(&ctx2, ctx.capn.seglist); checkStruct(&ctx2); }
TEST(WireFormat, CopyStruct) { Session ctx1, ctx2; setupStruct(&ctx1.capn); checkStruct(&ctx1.capn); capn_ptr root = capn_root(&ctx2.capn); EXPECT_EQ(0, capn_setp(root, 0, capn_getp(capn_root(&ctx1.capn), 0, 1))); checkStruct(&ctx2.capn); }
TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation_NoTag) { Session ctx; ctx.capn.create = &CreateSmallSegment; g_AddTag = 0; setupStruct(&ctx.capn); g_AddTag = 1; struct capn_segment *segments[31]; getSegments(&ctx.capn, segments, 31); // Check that each segment has the expected size. Note that we have plenty // of 16 byte double far ptrs. EXPECT_EQ( 8, segments[ 0]->len); // root ref EXPECT_EQ(64, segments[ 1]->len); // root struct EXPECT_EQ(16, segments[ 2]->len); // root struct ptr EXPECT_EQ( 8, segments[ 3]->len); // sub-struct EXPECT_EQ(16, segments[ 4]->len); // sub-struct ptr EXPECT_EQ(16, segments[ 5]->len); // 3-element int32 list EXPECT_EQ(16, segments[ 6]->len); // 3-element int32 list ptr EXPECT_EQ(72, segments[ 7]->len); // struct list EXPECT_EQ(16, segments[ 8]->len); // struct list ptr EXPECT_EQ( 8, segments[ 9]->len); // struct list substruct 1 EXPECT_EQ(16, segments[10]->len); // struct list substruct 1 ptr EXPECT_EQ( 8, segments[11]->len); // struct list substruct 2 EXPECT_EQ(16, segments[12]->len); // struct list substruct 2 ptr EXPECT_EQ( 8, segments[13]->len); // struct list substruct 3 EXPECT_EQ(16, segments[14]->len); // struct list substruct 3 ptr EXPECT_EQ( 8, segments[15]->len); // struct list substruct 4 EXPECT_EQ(16, segments[16]->len); // struct list substruct 4 ptr EXPECT_EQ(40, segments[17]->len); // list list EXPECT_EQ(16, segments[18]->len); // list list ptr EXPECT_EQ( 8, segments[19]->len); // list list sublist 1 EXPECT_EQ(16, segments[20]->len); // list list sublist 1 ptr EXPECT_EQ( 8, segments[21]->len); // list list sublist 2 EXPECT_EQ(16, segments[22]->len); // list list sublist 2 ptr EXPECT_EQ( 8, segments[23]->len); // list list sublist 3 EXPECT_EQ(16, segments[24]->len); // list list sublist 3 ptr EXPECT_EQ( 8, segments[25]->len); // list list sublist 4 EXPECT_EQ(16, segments[26]->len); // list list sublist 4 ptr EXPECT_EQ(16, segments[27]->len); // list list sublist 5 EXPECT_EQ(16, segments[28]->len); // list list sublist 5 ptr EXPECT_EQ(16, segments[29]->len); // recurse struct EXPECT_EQ(16, segments[30]->len); // recurse struct ptr checkStruct(&ctx.capn); struct capn ctx2; memset(&ctx2, 0, sizeof(ctx2)); for (int i = 0; i < sizeof(segments)/sizeof(segments[0]); i++) { capn_append_segment(&ctx2, segments[i]); } checkStruct(&ctx2); }
TEST(WireFormat, StructRoundTrip_MultipleSegmentsWithMultipleAllocations) { Session ctx; ctx.capn.create = &CreateSegment64; setupStruct(&ctx.capn); // Verify that we made 6 segments. ASSERT_EQ(6, ctx.capn.segnum); struct capn_segment *segments[6]; segments[0] = ctx.capn.seglist; for (int i = 1; i < 6; i++) { segments[i] = segments[i-1]->next; } for (int i = 0; i < 6; i++) { EXPECT_EQ(segments[i]->id, i); } // Check that each segment has the expected size. Recall that each object will be prefixed by an // extra word if its parent is in a different segment. EXPECT_EQ(64, segments[0]->len); // root ref (8), sub-struct (8+tag), 3-element list (16+tag), list substruct 1 (8+tag) EXPECT_EQ(72, segments[1]->len); // root struct (64+tag) EXPECT_EQ(80, segments[2]->len); // struct list (72+tag) EXPECT_EQ(64, segments[3]->len); // list substruct 2,3,4 3*(8+tag), sublist 3 (8+tag) EXPECT_EQ(64, segments[4]->len); // list list (40+tag), sublist 1,2 2*8 EXPECT_EQ(64, segments[5]->len); // sublist 4 (8+tag), 5 (16+tag), recurse struct (16+tag) checkStruct(&ctx.capn); struct capn ctx2; memset(&ctx2, 0, sizeof(ctx2)); for (int i = 0; i < sizeof(segments)/sizeof(segments[0]); i++) { capn_append_segment(&ctx2, segments[i]); } checkStruct(&ctx2); }
TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) { Session ctx; ctx.capn.create = &CreateSmallSegment; setupStruct(&ctx.capn); struct capn_segment *segments[16]; getSegments(&ctx.capn, segments, 16); // Check that each segment has the expected size. Recall that the first word of each segment will // actually be a reference to the first thing allocated within that segment. EXPECT_EQ( 8, segments[ 0]->len); // root ref EXPECT_EQ(72, segments[ 1]->len); // root struct EXPECT_EQ(16, segments[ 2]->len); // sub-struct EXPECT_EQ(24, segments[ 3]->len); // 3-element int32 list EXPECT_EQ(80, segments[ 4]->len); // struct list EXPECT_EQ(16, segments[ 5]->len); // struct list substruct 1 EXPECT_EQ(16, segments[ 6]->len); // struct list substruct 2 EXPECT_EQ(16, segments[ 7]->len); // struct list substruct 3 EXPECT_EQ(16, segments[ 8]->len); // struct list substruct 4 EXPECT_EQ(48, segments[ 9]->len); // list list EXPECT_EQ(16, segments[10]->len); // list list sublist 1 EXPECT_EQ(16, segments[11]->len); // list list sublist 2 EXPECT_EQ(16, segments[12]->len); // list list sublist 3 EXPECT_EQ(16, segments[13]->len); // list list sublist 4 EXPECT_EQ(24, segments[14]->len); // list list sublist 5 EXPECT_EQ(24, segments[15]->len); // recurse struct checkStruct(&ctx.capn); struct capn ctx2; memset(&ctx2, 0, sizeof(ctx2)); for (int i = 0; i < sizeof(segments)/sizeof(segments[0]); i++) { capn_append_segment(&ctx2, segments[i]); } checkStruct(&ctx2); }
void FacSys::FacSubMenu(){ char option; do { cout << "=========================================================\n" << " Facilities Management Subsystem\n" << "=========================================================\n" << endl; cout << "------------ Manage Club Facilities here ------------\n" << endl; cout << "1)\tAdd new Facility\n" << "2)\tEdit Facility\n" << "3)\tList all Facilities\n" << "9)\tBack to previous Menu\n" << endl; cout << "---------------------------------------------------------\n" << endl; cout << "Please enter your option: "; cin >> option; cin.clear(); cin.ignore(100, '\n'); cout << '\n' << endl; switch(option) { case '1': { addFacility(); //add Facility break; } case '2': editFacility(); //edit facility break; case '3': checkStruct(); //List every facility and their booking histories. break; case '9': cout << "Something!!"; break; //Quit default: cout << "\n[Invalid Option, Please Try Again]\n\n" << endl; } }while(option != '9'); }
void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string> &arrayTypeDefs) { for (std::list<Variable>::const_iterator i = scope->varlist.begin(); i != scope->varlist.end(); ++i) { if ((_tokenizer->isCPP() && i->type() && !i->isPointer() && i->type()->needInitialization != Type::True) || i->isStatic() || i->isExtern() || i->isReference()) continue; // don't warn for try/catch exception variable if (i->isThrow()) continue; if (i->nameToken()->strAt(1) == "(" || i->nameToken()->strAt(1) == "{" || i->nameToken()->strAt(1) == ":") continue; if (Token::Match(i->nameToken(), "%name% =")) { // Variable is initialized, but Rhs might be not checkRhs(i->nameToken(), *i, NO_ALLOC, 0U, ""); continue; } if (Token::Match(i->nameToken(), "%name% ) (") && Token::simpleMatch(i->nameToken()->linkAt(2), ") =")) { // Function pointer is initialized, but Rhs might be not checkRhs(i->nameToken()->linkAt(2)->next(), *i, NO_ALLOC, 0U, ""); continue; } if (i->isArray() || i->isPointerToArray()) { const Token *tok = i->nameToken()->next(); if (i->isPointerToArray()) tok = tok->next(); while (Token::simpleMatch(tok->link(), "] [")) tok = tok->link()->next(); if (Token::Match(tok->link(), "] =|{")) continue; } bool stdtype = _tokenizer->isC() && arrayTypeDefs.find(i->typeStartToken()->str()) == arrayTypeDefs.end(); const Token* tok = i->typeStartToken(); for (; tok != i->nameToken() && tok->str() != "<"; tok = tok->next()) { if (tok->isStandardType() || tok->isEnumType()) stdtype = true; } if (i->isArray() && !stdtype) continue; while (tok && tok->str() != ";") tok = tok->next(); if (!tok) continue; if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") && checkLoopBody(tok->astParent()->link()->next(), *i, i->isArray() ? ARRAY : NO_ALLOC, "", true)) continue; if (i->isArray()) { Alloc alloc = ARRAY; checkScopeForVariable(tok, *i, nullptr, nullptr, &alloc, ""); continue; } if (stdtype || i->isPointer()) { Alloc alloc = NO_ALLOC; checkScopeForVariable(tok, *i, nullptr, nullptr, &alloc, ""); } if (i->type()) checkStruct(tok, *i); } if (scope->function) { for (unsigned int i = 0; i < scope->function->argCount(); i++) { const Variable *arg = scope->function->getArgumentVar(i); if (arg && arg->declarationId() && Token::Match(arg->typeStartToken(), "%type% * %name% [,)]")) { // Treat the pointer as initialized until it is assigned by malloc for (const Token *tok = scope->classStart; tok != scope->classEnd; tok = tok->next()) { if (Token::Match(tok, "[;{}] %varid% = %name% (", arg->declarationId()) && _settings->library.returnuninitdata.count(tok->strAt(3)) == 1U) { if (arg->typeStartToken()->strAt(-1) == "struct" || (arg->type() && arg->type()->isStructType())) checkStruct(tok, *arg); else if (arg->typeStartToken()->isStandardType() || arg->typeStartToken()->isEnumType()) { Alloc alloc = NO_ALLOC; checkScopeForVariable(tok->next(), *arg, nullptr, nullptr, &alloc, ""); } } } } } } }