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, "");
}
}
}
}
}
}
}
