TEST_F (SquareRootTest, GivenNegativeNumber_WhenCalculating_ThenReturnIsFixed) {
// GIVEN
callConstructor();
object->setNumber(-18.0);
// WHEN
double expected = -1;
// THEN
EXPECT_EQ(expected, object->calculate());
}
TEST_F (SquareRootTest, GivenZero_WhenCalculating_ThenReturnIsZero) {
// GIVEN
callConstructor();
object->setNumber(0.0);
// WHEN
double expected = 0.0;
// THEN
EXPECT_EQ(expected, object->calculate());
}
TEST_F (SquareRootTest, GivenPositiveNumber_WhenCalculating_ThenGoodResult) {
// GIVEN
callConstructor();
object->setNumber(9.0);
// WHEN
double expected = 3.0;
// THEN
EXPECT_EQ(expected, object->calculate());
}
TEST_F (SquareRootTest, GivenAnyNumber_WhenSettingValue_ThenPropertyMustChange) {
// GIVEN
callConstructor();
object->setNumber(9.0);
// WHEN
double expected = 9.0;
// THEN
EXPECT_EQ(expected, object->getNumber());
}
TEST_F (SquareRootTest, GivenNoChange_WhenAnyMethodsCalled_ThenInitialValues) {
// GIVEN
callConstructor();
// WHEN
double expected = 0.0;
// THEN
EXPECT_EQ(expected, object->getNumber());
EXPECT_EQ(expected, object->calculate());
}
static EXPRESSION *createLambda(BOOLEAN noinline)
{
EXPRESSION *rv = NULL, **cur = &rv;
HASHREC *hr;
EXPRESSION *clsThs, *parentThs;
SYMBOL *cls = makeID(lambdas->enclosingFunc ? sc_auto : sc_localstatic, lambdas->cls->tp, NULL, AnonymousName());
SetLinkerNames(cls, lk_cdecl);
cls->allocate = TRUE;
if (lambdas->enclosingFunc)
{
insert(cls, localNameSpace->syms);
clsThs = varNode(en_auto, cls); // this ptr
}
else
{
insert(cls, globalNameSpace->syms); // well if we could put this as an auto in the init func that would be good but there is no way to do that here...
clsThs = varNode(en_label, cls); // this ptr
cls->label = nextLabel++;
insertInitSym(cls);
}
{
INITIALIZER *init = NULL;
EXPRESSION *exp = clsThs;
callDestructor(cls, NULL, &exp, NULL, TRUE, FALSE, FALSE);
initInsert(&init, cls->tp, exp, 0, TRUE);
if (cls->storage_class != sc_auto)
{
insertDynamicDestructor(cls, init);
}
else
{
cls->dest = init;
}
}
parentThs = varNode(en_auto, (SYMBOL *)basetype(lambdas->func->tp)->syms->table[0]->p); // this ptr
hr = lambdas->cls->tp->syms->table[0];
while (hr)
{
SYMBOL *sp = (SYMBOL *)hr->p;
EXPRESSION *en = NULL, *en1 = NULL;
if (!strcmp(sp->name, "$self"))
{
en1 = clsThs;
en = varNode(en_label, sp);
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (!strcmp(sp->name, "$parent"))
{
en1 = parentThs; // get parent from function call
deref(&stdpointer, &en1);
en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ;
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (!strcmp(sp->name, "$this"))
{
if (!lambdas->next || !lambdas->captureThis)
{
en1 = parentThs; // get parent from function call
}
else
{
SYMBOL *parent = search("$parent", lambdas->cls->tp->syms);
en1 = varNode(en_auto, cls);
deref(&stdpointer, &en1);
en1 = exprNode(en_add, en1, intNode(en_c_i, parent->offset));
}
deref(&stdpointer, &en1);
en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ;
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (sp->lambdaMode)
{
LAMBDASP *lsp = (LAMBDASP *)search(sp->name, lambdas->captured);
if (lsp)
{
en1 = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset));
if (sp->lambdaMode == cmRef)
{
SYMBOL *capture = lsp->parent;
deref(&stdpointer, &en1);
if (capture->lambdaMode)
{
en = parentThs;
deref(&stdpointer, &en);
en = exprNode(en_add, en, intNode(en_c_i, capture->offset));
}
else // must be an sc_auto
{
en = varNode(en_auto, capture);
}
if (isref(capture->tp))
{
deref(&stdpointer, &en);
}
en = exprNode(en_assign, en1, en);
}
else // cmValue
{
SYMBOL *capture = lsp->parent;
TYPE *ctp = capture->tp;
if (capture->lambdaMode)
{
en = parentThs;
deref(&stdpointer, &en);
en = exprNode(en_add, en, intNode(en_c_i, capture->offset));
}
else // must be an sc_auto
{
en = varNode(en_auto, capture);
}
if (isref(ctp))
{
ctp = basetype(ctp)->btp;
deref(&stdpointer, &en);
}
if (isstructured(ctp))
{
FUNCTIONCALL *params = (FUNCTIONCALL *)Alloc(sizeof(FUNCTIONCALL));
params->arguments = (INITLIST *)Alloc(sizeof(INITLIST));
params->arguments->tp = ctp;
params->arguments->exp = en;
if (!callConstructor(&ctp, &en1, params, FALSE, NULL, TRUE, FALSE, TRUE, FALSE, FALSE))
errorsym(ERR_NO_APPROPRIATE_CONSTRUCTOR, lsp->sym);
en = en1;
}
else
{
deref(ctp, &en1);
deref(ctp, &en);
en = exprNode(en_assign, en1, en);
}
}
}
else
{
diag("createLambda: no capture var");
}
}
if (en)
{
*cur = exprNode(en_void, en, NULL);
cur = &(*cur)->right;
}
hr = hr->next;
}
*cur = clsThs; // this expression will be used in copy constructors, or discarded if unneeded
return rv;
}
EXPRESSION *convertInitToExpression(TYPE *tp, SYMBOL *sp, SYMBOL *funcsp, INITIALIZER *init, EXPRESSION *thisptr, BOOLEAN isdest)
{
EXPRESSION *rv = NULL, **pos = &rv;
EXPRESSION *exp = NULL, **expp;
EXPRESSION *expsym;
BOOLEAN noClear = FALSE;
if (sp)
sp->destructed = FALSE;
if (isstructured(tp) || isarray(tp))
{
INITIALIZER **i2 = &init;
while (*i2)
i2 = &(*i2)->next;
initInsert(i2, NULL, NULL, tp->size, FALSE);
}
if (!sp)
{
if (thisptr)
expsym = thisptr;
else if (funcsp)
{
SYMBOL *sp = (SYMBOL *)basetype(funcsp->tp)->syms->table[0] ? (SYMBOL *)basetype(funcsp->tp)->syms->table[0]->p : NULL;
if (sp && sp->thisPtr)
expsym = varNode(en_auto, sp ); // this ptr
else
expsym = anonymousVar(sc_auto, tp);
}
else
{
expsym = intNode(en_c_i, 0);
diag("convertInitToExpression: no this ptr");
}
}
else switch (sp->storage_class)
{
case sc_auto:
case sc_register:
case sc_parameter:
expsym = varNode(en_auto, sp);
break;
case sc_localstatic:
if (sp->linkage3 == lk_threadlocal)
{
expsym = exprNode(en_add, thisptr, intNode(en_c_i, sp->offset));
}
else
{
expsym = varNode(en_label, sp);
}
break;
case sc_static:
case sc_global:
if (sp->linkage3 == lk_threadlocal)
{
expsym = exprNode(en_add, thisptr, intNode(en_c_i, sp->offset));
}
else
{
expsym = varNode(en_global, sp);
}
break;
case sc_member:
case sc_mutable:
if (thisptr)
expsym = thisptr;
else if (funcsp)
expsym = varNode(en_auto, (SYMBOL *)basetype(funcsp->tp)->syms->table[0]->p); // this ptr
else
{
expsym = intNode(en_c_i, 0);
diag("convertInitToExpression: no this ptr");
}
expsym = exprNode(en_add, expsym, intNode(en_c_i, sp->offset));
break;
case sc_external:
/* expsym = varNode(en_global, sp);
break;
*/
default:
diag("convertInitToExpression: unknown sym type");
expsym = intNode(en_c_i, 0);
break;
}
while (init)
{
exp = NULL;
if (init->basetp)
{
if (init->noassign)
{
exp = init->exp;
if (exp->type == en_thisref)
exp = exp->left;
if (thisptr && exp->type == en_func)
{
EXPRESSION *exp1 = init->offset ? exprNode(en_add, expsym, intNode(en_c_i, init->offset)) : expsym;
if (isarray(tp))
{
exp->v.func->arguments->exp = exp1;
}
else
{
exp->v.func->thisptr = exp1;
}
}
exp = init->exp;
}
else if (!init->exp)
{
// usually empty braces, coudl be an error though
exp = exprNode(en_blockclear, expsym, NULL);
exp->size = init->offset;
}
else if (isstructured(init->basetp) || isarray(init->basetp))
{
INITIALIZER *temp = init;
if (isstructured(temp->basetp))
{
EXPRESSION *exp2 = init->exp;
while(exp2->type == en_not_lvalue)
exp2 = exp2->left;
if (exp2->type == en_func && exp2->v.func->returnSP)
{
exp2->v.func->returnSP->allocate = FALSE;
exp2->v.func->returnEXP = expsym;
exp = exp2;
noClear = TRUE;
}
else if (exp2->type == en_thisref && exp2->left->v.func->returnSP)
{
exp2->left->v.func->returnSP->allocate = FALSE;
exp2->left->v.func->returnEXP = expsym;
exp = exp2;
noClear = TRUE;
}
else if (cparams.prm_cplusplus)
{
TYPE *ctype = init->basetp;
FUNCTIONCALL *funcparams = Alloc(sizeof(FUNCTIONCALL));
funcparams->arguments = Alloc(sizeof(INITLIST));
funcparams->arguments->tp = ctype;
funcparams->arguments->exp = exp2;
callConstructor(&ctype, &expsym, funcparams, FALSE, NULL, TRUE, FALSE, FALSE, FALSE, FALSE);
exp = expsym;
}
else
{
exp = exprNode(en_blockassign, expsym, exp2);
exp->size = init->basetp->size;
}
}
else
{
TYPE *btp = init->basetp;
while(isarray(btp))
btp = basetype(btp)->btp;
btp = basetype(btp);
while (temp)
{
if (temp->exp)
if (!isarithmeticconst(temp->exp) && !isconstaddress(temp->exp))
break;
temp = temp->next;
}
if (temp)
{
/* some members are non-constant expressions */
if (!cparams.prm_c99 && !cparams.prm_cplusplus)
error(ERR_C99_NON_CONSTANT_INITIALIZATION);
if (!sp)
{
expsym = anonymousVar(sc_auto, init->basetp);
sp = expsym->v.sp;
}
if (!isstructured(btp) || btp->sp->trivialCons)
{
exp = exprNode(en_blockclear, expsym, NULL);
exp->size = init->basetp->size;
exp = exprNode(en_void, exp, NULL);
expp = &exp->right;
}
else
{
expp = &exp;
}
{
EXPRESSION *right = init->exp;
if (!isstructured(btp))
{
EXPRESSION *asn = exprNode(en_add, expsym, intNode(en_c_i, init->offset));
deref(init->basetp, &asn);
cast(init->basetp, &right);
right = exprNode(en_assign, asn, right);
}
if (*expp)
*expp = exprNode(en_void, *expp, right);
else
*expp = right;
expp = &(*expp)->right;
}
}
else
{
/* constant expression */
SYMBOL *spc ;
IncGlobalFlag();
exp = anonymousVar(sc_localstatic, init->basetp);
spc = exp->v.sp;
spc->init = init ;
insertInitSym(spc);
insert(spc, localNameSpace->syms);
DecGlobalFlag();
spc->label =nextLabel++;
if (expsym)
{
if (cparams.prm_cplusplus && isstructured(init->basetp) && !init->basetp->sp->trivialCons)
{
TYPE *ctype = init->basetp;
FUNCTIONCALL *funcparams = Alloc(sizeof(FUNCTIONCALL));
funcparams->arguments = Alloc(sizeof(INITLIST));
funcparams->arguments->tp = ctype;
funcparams->arguments->exp = exp;
callConstructor(&ctype, &expsym, funcparams, FALSE, NULL, TRUE, FALSE, FALSE, FALSE, FALSE);
exp = expsym;
}
else
{
exp = exprNode(en_blockassign, expsym, exp);
exp->size = init->basetp->size;
}
}
}
}
}
else if (basetype(init->basetp)->type == bt_memberptr)
{
EXPRESSION *exp2 = init->exp;;
while(exp2->type == en_not_lvalue)
exp2 = exp2->left;
if (exp2->type == en_func && exp2->v.func->returnSP)
{
exp2->v.func->returnSP->allocate = FALSE;
exp2->v.func->returnEXP = expsym;
exp = exp2;
}
else
{
if (exp2->type == en_memberptr)
{
int lab = dumpMemberPtr(exp2->v.sp, init->basetp, TRUE);
exp2 = intNode(en_labcon, lab);
}
exp = exprNode(en_blockassign, expsym, exp2);
exp->size = init->basetp->size;
}
}
else
{
EXPRESSION *exps = expsym;
if (init->offset)
exps = exprNode(en_add, exps, intNode(en_c_i, init->offset));
deref(init->basetp, &exps);
exp = init->exp;
if (exp->type == en_void)
{
cast(init->basetp, &exp->right);
if (expsym)
exp->right = exprNode(en_assign, exps, exp->right);
}
else
{
cast(init->basetp, &exp);
if (exps)
exp = exprNode(en_assign, exps, exp);
}
}
if (sp && sp->init && isatomic(init->basetp) && needsAtomicLockFromType(init->basetp))
{
EXPRESSION *p1 = exprNode(en_add, expsym->left, intNode(en_c_i, init->basetp->size - ATOMIC_FLAG_SPACE));
deref(&stdint, &p1);
p1 = exprNode(en_assign, p1, intNode(en_c_i, 0));
exp = exprNode(en_void, exp, p1);
}
}
if (exp)
{
if (*pos)
{
*pos = exprNode(en_void, *pos, exp);
pos = &(*pos)->right;
}
else
{
*pos = exp;
}
}
init = init->next;
}
if (sp && sp->storage_class == sc_localstatic)
{
if (isdest)
{
rv = exprNode(en_voidnz, exprNode(en_void, sp->localInitGuard, rv), intNode(en_c_i, 0));
}
else
{
EXPRESSION *guard = anonymousVar(sc_static, &stdint);
insertInitSym(guard->v.sp);
deref(&stdpointer, &guard);
optimize_for_constants(&rv);
rv = exprNode(en_voidnz, exprNode(en_void,
exprNode(en_not, guard, NULL),
exprNode(en_void, rv, exprNode(en_autoinc, guard, intNode(en_c_i, 1)))), intNode(en_c_i, 0));
sp->localInitGuard = guard;
}
}
// plop in a clear block if necessary
if (sp && !noClear && !isdest && (isarray(tp) || isstructured(tp) && (!cparams.prm_cplusplus || basetype(tp)->sp->trivialCons)))
{
EXPRESSION *fexp = expsym;
EXPRESSION *exp;
if (fexp->type == en_thisref)
fexp = fexp->left->v.func->thisptr;
exp = exprNode(en_blockclear, fexp, NULL);
exp->size = sp->tp->size;
rv = exprNode(en_void, exp, rv);
}
if (isstructured(tp) && !cparams.prm_cplusplus)
{
if (*pos)
{
*pos = exprNode(en_void, *pos, expsym);
pos = &(*pos)->right;
}
else
{
*pos = expsym;
}
}
return rv;
}
