TEST_F(BodyTest, RotatingSerializationSuccess) { EXPECT_FALSE(rotating_body_.is_massless()); EXPECT_FALSE(rotating_body_.is_oblate()); serialization::Body message; RotatingBody<World> const* cast_rotating_body; rotating_body_.WriteToMessage(&message); EXPECT_TRUE(message.has_massive_body()); EXPECT_FALSE(message.has_massless_body()); EXPECT_TRUE(message.massive_body().HasExtension( serialization::RotatingBody::rotating_body)); EXPECT_EQ(17, message.massive_body().gravitational_parameter().magnitude()); serialization::RotatingBody const rotating_body_extension = message.massive_body().GetExtension( serialization::RotatingBody::rotating_body); EXPECT_EQ(3, rotating_body_extension.reference_angle().magnitude()); EXPECT_EQ(4, rotating_body_extension.reference_instant().scalar().magnitude()); EXPECT_EQ(angular_velocity_, AngularVelocity<World>::ReadFromMessage( rotating_body_extension.angular_velocity())); // Dispatching from |MassiveBody|. not_null<std::unique_ptr<MassiveBody const>> const massive_body = MassiveBody::ReadFromMessage(message); EXPECT_EQ(rotating_body_.gravitational_parameter(), massive_body->gravitational_parameter()); cast_rotating_body = dynamic_cast<RotatingBody<World> const*>(&*massive_body); EXPECT_THAT(cast_rotating_body, NotNull()); EXPECT_EQ(rotating_body_.gravitational_parameter(), cast_rotating_body->gravitational_parameter()); EXPECT_EQ(rotating_body_.angular_velocity(), cast_rotating_body->angular_velocity()); EXPECT_EQ(rotating_body_.AngleAt(Instant()), cast_rotating_body->AngleAt(Instant())); // Dispatching from |Body|. not_null<std::unique_ptr<Body const>> const body = Body::ReadFromMessage(message); cast_rotating_body = dynamic_cast<RotatingBody<World> const*>(&*body); EXPECT_THAT(cast_rotating_body, NotNull()); EXPECT_EQ(rotating_body_.gravitational_parameter(), cast_rotating_body->gravitational_parameter()); EXPECT_EQ(rotating_body_.angular_velocity(), cast_rotating_body->angular_velocity()); EXPECT_EQ(rotating_body_.AngleAt(Instant()), cast_rotating_body->AngleAt(Instant())); }
bool HTTPBodyParameterMapper::DoFinalGetStream(const char *key, std::ostream &os, Context &ctx) { StartTrace1(HTTPBodyParameterMapper.DoFinalGetStream, NotNull(key)); bool mapSuccess = true; ROAnything params(ctx.Lookup(key)); //!@FIXME ??: use Get(key,any,ctx) instead? if (!params.IsNull()) { long bPSz = params.GetSize(); String value; for (long i = 0; i < bPSz; ++i) { const char *lookupVal = params.SlotName(i); if (!lookupVal) { lookupVal = params[i].AsCharPtr(""); } if (lookupVal && (mapSuccess = Get(lookupVal, value, ctx))) { Trace("Param[" << lookupVal << "]=<" << value << ">"); os << lookupVal << "=" << value; if (i < (bPSz - 1)) { os << "&"; } } else { mapSuccess = true; os << lookupVal; } value.clear(); } } else { String bodyParams; if ((mapSuccess = Get(key, bodyParams, ctx))) { os << bodyParams; } } Trace("retval: " << mapSuccess); return mapSuccess; }
/** * @brief Convenience function to pass a single logical tile through an * executor which has only one child. * @param executor Executor to pass logical tile through. * @param source_logical_tile Logical tile to pass through executor. * @param check the value of logical tiles * * @return Pointer to processed logical tile. */ executor::LogicalTile *ExecutorTestsUtil::ExecuteTile( executor::AbstractExecutor *executor, executor::LogicalTile *source_logical_tile) { MockExecutor child_executor; executor->AddChild(&child_executor); // Uneventful init... EXPECT_CALL(child_executor, DInit()).WillOnce(Return(true)); EXPECT_TRUE(executor->Init()); // Where the main work takes place... EXPECT_CALL(child_executor, DExecute()) .WillOnce(Return(true)) .WillOnce(Return(false)); EXPECT_CALL(child_executor, GetOutput()) .WillOnce(Return(source_logical_tile)); EXPECT_TRUE(executor->Execute()); std::unique_ptr<executor::LogicalTile> result_logical_tile( executor->GetOutput()); EXPECT_THAT(result_logical_tile, NotNull()); EXPECT_THAT(executor->Execute(), false); return result_logical_tile.release(); }
void TestRotatingBody() { using F = Frame<Tag, tag, true>; AngularVelocity<F> const angular_velocity = AngularVelocity<F>({-1 * Radian / Second, 2 * Radian / Second, 5 * Radian / Second}); auto const rotating_body = RotatingBody<F>(17 * SIUnit<GravitationalParameter>(), typename RotatingBody<F>::Parameters( 3 * Radian, Instant() + 4 * Second, angular_velocity)); serialization::Body message; RotatingBody<F> const* cast_rotating_body; rotating_body.WriteToMessage(&message); EXPECT_TRUE(message.has_massive_body()); EXPECT_FALSE(message.has_massless_body()); EXPECT_TRUE(message.massive_body().HasExtension( serialization::RotatingBody::rotating_body)); not_null<std::unique_ptr<MassiveBody const>> const massive_body = MassiveBody::ReadFromMessage(message); EXPECT_EQ(rotating_body.gravitational_parameter(), massive_body->gravitational_parameter()); cast_rotating_body = dynamic_cast<RotatingBody<F> const*>(&*massive_body); EXPECT_THAT(cast_rotating_body, NotNull()); }
double LookupInterface::Lookup(const char *key, double dflt, char delim, char indexdelim) const { StartTrace1(LookupInterface.LookupDouble, "key: <" << NotNull(key) << ">" << " default: " << dflt << " delim: " << delim << " indexdelim: " << indexdelim); ROAnything a; if (DoLookup(key, a, delim, indexdelim)) { return a.AsDouble(dflt); } return dflt; }
bool RegExpFilterFieldsParameterMapper::interpretMapperScript(const char *key, std::ostream &os, Context &ctx, ROAnything script) { StartTrace1(RegExpFilterFieldsParameterMapper.interpretMapperScript, "( \"" << NotNull(key) << "\" , std::ostream &os, Context &ctx, ROAnything script)"); ROAnything dummyResult; if ( ctx.Lookup(_ShortCutKey, dummyResult) ) { return ParameterMapper::interpretMapperScript(key, os, ctx, script); } return intInterpretMapperScript(key, os, ctx, script); }
bool HTTPHeaderFieldParameterMapper::DoGetAny(const char *key, Anything &value, Context &ctx, ROAnything info) { StartTrace1(HTTPHeaderFieldParameterMapper.DoGetAny, "Key:<" << NotNull(key) << ">"); String strBuf(128L); OStringStream osStr(strBuf); if (DoGetStream(key, osStr, ctx, info)) { osStr.flush(); value = strBuf; return true; } return false; }
TEST_F(BodyTest, OblateSerializationSuccess) { EXPECT_FALSE(oblate_body_.is_massless()); EXPECT_TRUE(oblate_body_.is_oblate()); serialization::Body message; OblateBody<World> const* cast_oblate_body; oblate_body_.WriteToMessage(&message); EXPECT_TRUE(message.has_massive_body()); EXPECT_FALSE(message.has_massless_body()); EXPECT_TRUE(message.massive_body().GetExtension( serialization::RotatingBody::rotating_body). HasExtension(serialization::OblateBody::oblate_body)); EXPECT_EQ(17, message.massive_body().gravitational_parameter().magnitude()); serialization::OblateBody const oblate_body_extension = message.massive_body().GetExtension( serialization::RotatingBody::rotating_body). GetExtension(serialization::OblateBody::oblate_body); EXPECT_EQ(163, oblate_body_extension.j2().magnitude()); // Dispatching from |MassiveBody|. not_null<std::unique_ptr<MassiveBody const>> const massive_body = MassiveBody::ReadFromMessage(message); EXPECT_EQ(oblate_body_.gravitational_parameter(), massive_body->gravitational_parameter()); cast_oblate_body = dynamic_cast<OblateBody<World> const*>(&*massive_body); EXPECT_THAT(cast_oblate_body, NotNull()); EXPECT_EQ(oblate_body_.gravitational_parameter(), cast_oblate_body->gravitational_parameter()); EXPECT_EQ(oblate_body_.j2(), cast_oblate_body->j2()); EXPECT_EQ(oblate_body_.axis(), cast_oblate_body->axis()); // Dispatching from |Body|. not_null<std::unique_ptr<Body const>> const body = Body::ReadFromMessage(message); cast_oblate_body = dynamic_cast<OblateBody<World> const*>(&*body); EXPECT_THAT(cast_oblate_body, NotNull()); EXPECT_EQ(oblate_body_.gravitational_parameter(), cast_oblate_body->gravitational_parameter()); EXPECT_EQ(oblate_body_.j2(), cast_oblate_body->j2()); EXPECT_EQ(oblate_body_.axis(), cast_oblate_body->axis()); }
bool HierarchyInstaller::InstallRoot(HierarchConfNamed *root, const char *name) { StartTrace1(HierarchyInstaller.InstallRoot, "root [" << NotNull(name) << "]" << (root ? "" : " is null!")); if (root) { // AB: don't create cycles in inheritance tree if (HasSuper(root->GetSuper(), name)) { Trace(""); return false; } return true; } return false; }
bool RegExpFilterFieldsParameterMapper::getValueWithSlotname(const char *key, String const &strSlotname, Context & ctx, ValueType & value, ROAnything script) { StartTrace1(RegExpFilterFieldsParameterMapper.getValueWithSlotname, "key [" << NotNull(key) << "] slotname [" << strSlotname << "]"); String strNewKey = key; if (Lookup(_CombineKeyName, 1L) != 0) { strNewKey.Append(getDelim()).Append(strSlotname); } Anything slotnameBuffer = strSlotname, combinedKeyBuffer = strNewKey; Context::PushPopEntry<Anything> aSlotnameEntry(ctx, "CurrentSlotname", slotnameBuffer, _CurrentSlotname); Context::PushPopEntry<Anything> aCombinedEntry(ctx, "CombinedKey", combinedKeyBuffer, _CombinedKeyName); return doGetValue(strNewKey, value, ctx, script); }
bool AnythingLookupPathResultMapper::DoPutAnyWithSlotname(const char *key, Anything &value, Context &ctx, ROAnything roaScript, const char *slotname) { StartTrace1(AnythingLookupPathResultMapper.DoPutAnyWithSlotname, "key [" << NotNull(key) << "] slotname [" << NotNull(slotname) << "]"); Trace("Using slotname [" << slotname << "] as Lookup path in value"); bool bRet = true; // do not fail when lookup fails! Anything anyValue; if ( value.LookupPath(anyValue, slotname) ) { TraceAny(anyValue, "Calling myself again with Anything looked up at [" << slotname << "]"); bRet = DoPutAny(key, anyValue, ctx, roaScript); Trace("RetCode of DoPutAny:" << (bRet ? "true" : "false")); } return bRet; }
void ConfiguredActionTest::DoTest(Anything testCase, const char *testCaseName, Context &ctx) { StartTrace1(ConfiguredActionTest.DoTest, "<" << NotNull(testCaseName) << ">"); DoTestWithContext(testCase, testCaseName, ctx); // do existence tests Anything anyFailureStrings; coast::testframework::CheckStores(anyFailureStrings, testCase["Result"], ctx, testCaseName, coast::testframework::exists); // non-existence tests coast::testframework::CheckStores(anyFailureStrings, testCase["NotResult"], ctx, testCaseName, coast::testframework::notExists); for (long sz = anyFailureStrings.GetSize(), i = 0; i < sz; ++i) { t_assertm(false, anyFailureStrings[i].AsString().cstr()); } }
bool HTTPHeaderFieldParameterMapper::DoGetStream(const char *key, std::ostream &os, Context &ctx, ROAnything info) { StartTrace1(HTTPHeaderFieldParameterMapper.DoGetStream, "Key:<" << NotNull(key) << ">"); Anything fieldValues; //! break potential loop here when our own DoGetAny is calling us ParameterMapper::DoGetAny(key, fieldValues, ctx, SelectScript(key, fConfig, ctx)); String potentiallyCombinedKey = key; TraceAny(fieldValues, "field values available for full key [" << potentiallyCombinedKey << "]"); String headerFieldName = potentiallyCombinedKey.SubString(potentiallyCombinedKey.StrRChr(getDelim()) + 1).ToUpper(); Trace("field name only [" << headerFieldName << "]"); if (!fieldValues.IsNull()) { coast::http::putHeaderFieldToStream(os, ctx, headerFieldName, fieldValues); } return true; }
bool RegExpFilterFieldsParameterMapper::intInterpretMapperScript(const char *key, ValueType &value, Context &ctx, ROAnything script) { StartTrace1(RegExpFilterFieldsParameterMapper.intInterpretMapperScript, "( \"" << NotNull(key) << "\" , ValueType &value, Context &ctx, ROAnything script)"); Anything availableContent; if ( not DoFinalGetAny(key, availableContent, ctx) ) { return false; } Context::PushPopEntry<Anything> aSlotnameEntry(ctx, "ShortCutEntry", availableContent, _ShortCutKey); bool retval = true; // iterate over list of regular expressions specified in the slotname for (long i = 0, sz = script.GetSize(); retval && i < sz; ++i) { retval = getValueWithSlotnameCommon(key, script.SlotName(i), ctx, value, script[i], availableContent); } return retval; }
bool CgiParams::DoGetAny(const char *key, Anything &value, Context &ctx, ROAnything config) { StartTrace1(CgiParams.DoGetAny, "( \"" << NotNull(key) << "\" , Anything &value, Context &ctx, const ROAnything &config)"); String k(key); // for easier comparison if (k == "cgienv") { Trace("key found"); SynthesizeMinimalCGIEnvironment(value, ctx); AddToEnvironment(ctx, value, ctx.Lookup("cgienv")); AddToEnvironment(ctx, value, Lookup("cgienv")); //!@FIXME double entry with next one? AddToEnvironment(ctx, value, config["cgienv"]); // already discriminated when scripted return true; } Trace("unknown key [" << key << "] using ParamterMapper::DoGetAny(key, value, ctx, config)"); return URI2FileNameMapper::DoGetAny(key, value, ctx, config); }
bool CgiParams::DoGetStream(const char *key, std::ostream &os, Context &ctx, ROAnything config) { StartTrace1(CgiParams.DoGetStream, "( \"" << NotNull(key) << "\" , ostream &os, Context &ctx, const ROAnything &config)"); String k(key); // for easier comparison if (k == "stdin") { Trace("key found"); //!@FIXME should use Get("WHOLE_REQUEST_BODY",body,ctx); String body = ctx.Lookup("WHOLE_REQUEST_BODY").AsString(""); if (body.Length() > 0) { os << body; Trace("Written request body of length: " << body.Length()); } return true; } Trace("unknown key [" << key << "] using URI2FileNameMapper::DoGetStream(key, os, ctx, config)"); return URI2FileNameMapper::DoGetStream(key, os, ctx, config); }
// "Pass-through" test case. There is nothing to materialize as // there is only one base tile in the logical tile. TEST_F(MaterializationTests, SingleBaseTileTest) { const int tuple_count = 9; std::shared_ptr<storage::TileGroup> tile_group( ExecutorTestsUtil::CreateTileGroup(tuple_count)); ExecutorTestsUtil::PopulateTiles(tile_group, tuple_count); // Create logical tile from single base tile. auto source_base_tile = tile_group->GetTileReference(0); // Add a reference because we are going to wrap around it and we don't own it std::unique_ptr<executor::LogicalTile> source_logical_tile( executor::LogicalTileFactory::WrapTiles({source_base_tile})); // Pass through materialization executor. executor::MaterializationExecutor executor(nullptr, nullptr); std::unique_ptr<executor::LogicalTile> result_logical_tile( ExecutorTestsUtil::ExecuteTile(&executor, source_logical_tile.release())); // Verify that logical tile is only made up of a single base tile. int num_cols = result_logical_tile->GetColumnCount(); EXPECT_EQ(2, num_cols); storage::Tile *result_base_tile = result_logical_tile->GetBaseTile(0); EXPECT_THAT(result_base_tile, NotNull()); EXPECT_TRUE(source_base_tile.get() == result_base_tile); EXPECT_EQ(result_logical_tile->GetBaseTile(1), result_base_tile); // Check that the base tile has the correct values. for (int i = 0; i < tuple_count; i++) { type::Value val0 = (result_base_tile->GetValue(i, 0)); type::Value val1 = (result_base_tile->GetValue(i, 1)); type::CmpBool cmp = (val0.CompareEquals( type::ValueFactory::GetIntegerValue(ExecutorTestsUtil::PopulatedValue(i, 0)))); EXPECT_TRUE(cmp == type::CMP_TRUE); cmp = val1.CompareEquals(type::ValueFactory::GetIntegerValue( ExecutorTestsUtil::PopulatedValue(i, 1))); EXPECT_TRUE(cmp == type::CMP_TRUE); // Double check that logical tile is functioning. type::Value logic_val0 = (result_logical_tile->GetValue(i, 0)); type::Value logic_val1 = (result_logical_tile->GetValue(i, 1)); cmp = (logic_val0.CompareEquals(val0)); EXPECT_TRUE(cmp == type::CMP_TRUE); cmp = (logic_val1.CompareEquals(val1)); EXPECT_TRUE(cmp == type::CMP_TRUE); } }
bool InvoiceList::prepare() { String sqlStatement = "select r.invoice_id, r.inv_create_date, \ (select sum(ri.item_price) from record_item ri where ri.record_id = r.id) \ from record r \ where r.invoice_id is not null and r.inv_create_date between '" + AsString(from) + "' and '" + AsString(to) + "' order by r.inv_create_date, r.invoice_id"; SQL.Execute(sqlStatement); bool found = false; while (SQL.Fetch()) { found = true; VectorMap<int, String> vmap; vmap.Add(iliInvNum, AsString(SQL[0])); vmap.Add(iliDate, AsString(SQL[1])); vmap.Add(iliTotal, fixFuckedLinuxFormating(ConvertMoney().Format(SQL[2]))); inv_list_items.Add(vmap); } if (!found) return false; SQL & Select(SqlSum(ITEM_PRICE.Of(RECORD_ITEM))).From(RECORD_ITEM) .InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD)) .Where(NotNull(INVOICE_ID.Of(RECORD)) && (Between(INV_CREATE_DATE.Of(RECORD), from, to))); if (SQL.Fetch()) summary_price = SQL[0]; invoiceList.Clear(); invoiceList.Header(String("[A0> ") + String(t_("Page")) + String(" $$P")); StringBuffer buf; buf.Cat("{{1f4 "); formatHeader(buf); buf.Cat(":: "); formatCompanyData(buf); buf.Cat(":: "); formatItems(buf); buf.Cat("}}"); LOG(~buf); invoiceList << ~buf; return true; }
bool LocalizationModule::Init(const ROAnything config) { StartTrace(LocalizationModule.Init); // add localized strings if (config.IsDefined("StringFile")) { Trace("loading StringFile [" << NotNull(config["StringFile"].AsCharPtr()) << "]"); if (!ReadFromFile(fLocalizedStrings, config["StringFile"].AsCharPtr())) { return false; } } LocalizedStrings *theHandle = LocalizedStrings::LocStr(); Assert(theHandle); if (theHandle) { theHandle->fLocalizedStrings = fLocalizedStrings; } return 0 != theHandle; }
bool StreamToAnythingMapper::DoPutStream(const char *key, std::istream &is, Context &ctx, ROAnything script) { StartTrace1(StreamToAnythingMapper.DoPutStream, NotNull(key)); Anything anyResult; bool importok; { DAAccessTimer(StreamToAnythingMapper.DoPutStream, "importing from stream", ctx); importok = anyResult.Import(is); } if ( importok ) { TraceAny(anyResult, "anything imported from stream:"); importok = DoPutAny(key, anyResult, ctx, script); } else { SYSWARNING("importing Anything from stream failed!"); } return importok; }
bool AnythingToStreamMapper::DoFinalGetStream(const char *key, std::ostream &os, Context &ctx) { StartTrace1(AnythingToStreamMapper.DoFinalGetStream, NotNull(key)); if ( key ) { // use the superclass mapper to get the anything Anything anyValue; DoFinalGetAny(key, anyValue, ctx); TraceAny(anyValue, "value fetched from context"); if ( !anyValue.IsNull() ) { DAAccessTimer(AnythingToStreamMapper.DoFinalGetStream, "exporting to stream", ctx); os << anyValue << std::flush; TraceAny(anyValue, "written to stream:"); return true; } Trace("Nothing written to stream, value was null."); } return false; }
TEST_F(BodyTest, MasslessSerializationSuccess) { EXPECT_TRUE(massless_body_.is_massless()); EXPECT_FALSE(massless_body_.is_oblate()); serialization::Body message; MasslessBody const* cast_massless_body; massless_body_.WriteToMessage(&message); EXPECT_TRUE(message.has_massless_body()); EXPECT_FALSE(message.has_massive_body()); // Direct deserialization. // No members to test in this class, we just check that it doesn't crash. massless_body_ = *MasslessBody::ReadFromMessage(message); // Dispatching from |Body|. Need two steps to add const and remove // |not_null|. std::unique_ptr<Body const> const body = not_null<std::unique_ptr<Body const>>(Body::ReadFromMessage(message)); cast_massless_body = dynamic_cast<MasslessBody const*>(body.get()); EXPECT_THAT(cast_massless_body, NotNull()); }
LevelConfig::LevelConfig(std::string fileName) { initialize(fileName); CCLOG("LevelConfig:: Parsing level file."); rapidxml::xml_node<>* levelRoot = this->_doc.first_node("level-config"); this->_transitionName = NotNull(levelRoot->first_attribute("transition-to")); CCLOG("LevelConfig:: Generating BackgroundDescriptor..."); rapidxml::xml_node<>* background = NotNullTag(levelRoot->first_node("background")); this->_back = new BackgroundDescriptor(background); CCLOG("LevelConfig:: Generating ElementsDescriptor..."); rapidxml::xml_node<>* elements = NotNullTag(levelRoot->first_node("elements")); this->_elems = new ElementsDescriptor(elements); CCLOG("LevelConfig:: Level parsed successfully."); }
bool HierarchyInstaller::HasSuper(const HierarchConfNamed *super, const char *name) const { StartTrace1(HierarchyInstaller.HasSuper, "name [" << NotNull(name) << "] addr:" << (long)super); if (!name) { return false; } // get the name String superName; // check for equal names in the parent relationship while (super) { super->GetName(superName); Trace("current class is [" << superName << "] addr:" << (long)super); if (superName == name) { Trace("super class found with same name"); return true; } super = super->GetSuper(); Trace("next super-class is [" << (super ? super->GetName() : "<null>") << "] addr:" << (long)super); } return false; }
bool HTTPHeaderParameterMapper::DoGetStream(const char *key, std::ostream &os, Context &ctx, ROAnything info) { StartTrace1(HTTPHeaderParameterMapper.DoGetStream, "Key:<" << NotNull(key) << ">"); bool mapSuccess = true; ROAnything headerfields(ctx.Lookup(key)); TraceAny(headerfields, "Headerfields available for key " << key); if (!headerfields.IsNull()) { String strFieldName; ROAnything roaValue; AnyExtensions::Iterator<ROAnything> headerIterator(headerfields); while (headerIterator.Next(roaValue)) { if (headerIterator.SlotName(strFieldName)) { strFieldName.ToUpper(); String strKey(constants::suppressName); strKey.Append('.').Append(strFieldName); Trace("trying to Lookup [" << strKey << "] in own or config"); // map non suppressed headerfields if (Lookup(strKey).AsLong(0L) == 0L) { Anything value; ROAnything rvalue; Trace("slot: " << strFieldName); if (!Get(strFieldName, value, ctx)) { rvalue = roaValue; } else { rvalue = value; } coast::http::putHeaderFieldToStream(os, ctx, strFieldName, rvalue); } } } } else { TraceAny(ctx.GetTmpStore(), "no headers, get ReqHeader in tmp store:"); String strHeaderfields; if ((mapSuccess = Get("ReqHeader", strHeaderfields, ctx))) { os << strHeaderfields; } } Trace("retval: " << mapSuccess); return mapSuccess; }
// The best serialization revenge. TEST_F(BodyTest, MassiveSerializationSuccess) { EXPECT_FALSE(massive_body_.is_massless()); EXPECT_FALSE(massive_body_.is_oblate()); serialization::Body message; MassiveBody const* cast_massive_body; massive_body_.WriteToMessage(&message); EXPECT_TRUE(message.has_massive_body()); EXPECT_FALSE(message.has_massless_body()); EXPECT_EQ(42, message.massive_body().gravitational_parameter().magnitude()); // Direct deserialization. MassiveBody const massive_body = *MassiveBody::ReadFromMessage(message); EXPECT_EQ(massive_body_.gravitational_parameter(), massive_body.gravitational_parameter()); // Dispatching from |Body|. not_null<std::unique_ptr<Body>> body = Body::ReadFromMessage(message); cast_massive_body = dynamic_cast<MassiveBody*>(&*body); EXPECT_THAT(cast_massive_body, NotNull()); EXPECT_EQ(massive_body_.gravitational_parameter(), cast_massive_body->gravitational_parameter()); }
bool NullParameterMapper::DoGetAny(const char *key, Anything &value, Context &ctx, ROAnything script) { StartTrace1(NullParameterMapper.DoGetAny, NotNull(key)); if (ParameterMapper::DoGetAny(key, value, ctx, script)) { Trace("value before replacement [" << (value.IsNull()?String("*"):value.AsString()) << "]"); ROAnything roaTreatAsNullValues = Lookup("TreatAsNull"); if (!value.IsNull() && !roaTreatAsNullValues.IsNull()) { ROAnything roaTestValue; AnyExtensions::Iterator<ROAnything> nullValIterator(roaTreatAsNullValues); while (nullValIterator.Next(roaTestValue)) { Trace("testing against listvalue [" << roaTestValue.AsString() << "]"); if (roaTestValue.IsEqual(value)) { Trace("value matched in list [" << value.AsString() << "]"); value = Anything(value.GetAllocator()); break; } } } Trace("returning true and value [" << (value.IsNull()?String("*"):value.AsString()) << "]"); return true; } Trace("returning false and value [" << (value.IsNull()?String("*"):value.AsString()) << "]"); return false; }
TEST_F(BodyTest, MasslessSerializationSuccess) { EXPECT_TRUE(massless_body_.is_massless()); EXPECT_FALSE(massless_body_.is_oblate()); serialization::Body message; MasslessBody const* cast_massless_body; massless_body_.WriteToMessage(&message); EXPECT_TRUE(message.has_massless_body()); EXPECT_FALSE(message.has_massive_body()); // Direct deserialization. // No members to test in this class, we just check that it doesn't crash. massless_body_ = *MasslessBody::ReadFromMessage(message); // Dispatching from |Body|. not_null<std::unique_ptr<Body const>> const body = Body::ReadFromMessage(message); // NOTE(egg): The &* is a quick way to explicitly forget |not_null|ness. We // cannot strip the |not_null| from the previous line because MSVC does not // support move conversion at the moment. cast_massless_body = dynamic_cast<MasslessBody const*>(&*body); EXPECT_THAT(cast_massless_body, NotNull()); }
void ExecuteTileGroupTest() { const int tuples_per_tilegroup_count = 10; const int tile_group_count = 5; const int tuple_count = tuples_per_tilegroup_count * tile_group_count; const oid_t col_count = 250; const bool is_inlined = true; const bool indexes = false; std::vector<catalog::Column> columns; for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) { auto column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "FIELD" + std::to_string(col_itr), is_inlined); columns.push_back(column); } catalog::Schema *table_schema = new catalog::Schema(columns); std::string table_name("TEST_TABLE"); ///////////////////////////////////////////////////////// // Create table. ///////////////////////////////////////////////////////// bool own_schema = true; bool adapt_table = true; std::unique_ptr<storage::DataTable> table(storage::TableFactory::GetDataTable( INVALID_OID, INVALID_OID, table_schema, table_name, tuples_per_tilegroup_count, own_schema, adapt_table)); // PRIMARY INDEX if (indexes == true) { std::vector<oid_t> key_attrs; auto tuple_schema = table->GetSchema(); catalog::Schema *key_schema; index::IndexMetadata *index_metadata; bool unique; key_attrs = {0}; key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); unique = true; index_metadata = new index::IndexMetadata( "primary_index", 123, INDEX_TYPE_BTREE, INDEX_CONSTRAINT_TYPE_PRIMARY_KEY, tuple_schema, key_schema, unique); index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata); table->AddIndex(pkey_index); } ///////////////////////////////////////////////////////// // Load in the data ///////////////////////////////////////////////////////// // Insert tuples into tile_group. auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); const bool allocate = true; auto txn = txn_manager.BeginTransaction(); auto testing_pool = TestingHarness::GetInstance().GetTestingPool(); for (int rowid = 0; rowid < tuple_count; rowid++) { int populate_value = rowid; storage::Tuple tuple(table_schema, allocate); for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) { auto value = ValueFactory::GetIntegerValue(populate_value + col_itr); tuple.SetValue(col_itr, value, testing_pool); } ItemPointer tuple_slot_id = table->InsertTuple(&tuple); EXPECT_TRUE(tuple_slot_id.block != INVALID_OID); EXPECT_TRUE(tuple_slot_id.offset != INVALID_OID); txn_manager.PerformInsert(tuple_slot_id.block, tuple_slot_id.offset); } txn_manager.CommitTransaction(); ///////////////////////////////////////////////////////// // Do a seq scan with predicate on top of the table ///////////////////////////////////////////////////////// txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); // Column ids to be added to logical tile after scan. // std::vector<oid_t> column_ids; // for(oid_t col_itr = 0 ; col_itr <= 200; col_itr++) { // column_ids.push_back(col_itr); //} std::vector<oid_t> column_ids({198, 206}); // Create and set up seq scan executor planner::SeqScanPlan seq_scan_node(table.get(), nullptr, column_ids); int expected_num_tiles = tile_group_count; executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); // Create and set up materialization executor std::vector<catalog::Column> output_columns; std::unordered_map<oid_t, oid_t> old_to_new_cols; oid_t col_itr = 0; for (auto column_id : column_ids) { auto column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "FIELD" + std::to_string(column_id), is_inlined); output_columns.push_back(column); old_to_new_cols[col_itr] = col_itr; col_itr++; } std::unique_ptr<catalog::Schema> output_schema( new catalog::Schema(output_columns)); bool physify_flag = true; // is going to create a physical tile planner::MaterializationPlan mat_node(old_to_new_cols, output_schema.release(), physify_flag); executor::MaterializationExecutor mat_executor(&mat_node, nullptr); mat_executor.AddChild(&seq_scan_executor); EXPECT_TRUE(mat_executor.Init()); std::vector<std::unique_ptr<executor::LogicalTile>> result_tiles; for (int i = 0; i < expected_num_tiles; i++) { EXPECT_TRUE(mat_executor.Execute()); std::unique_ptr<executor::LogicalTile> result_tile( mat_executor.GetOutput()); EXPECT_THAT(result_tile, NotNull()); result_tiles.emplace_back(result_tile.release()); } EXPECT_FALSE(mat_executor.Execute()); txn_manager.CommitTransaction(); }
XMLElement::operator bool() const { return NotNull(); }