static bool test_find_no_subheaders(void) { bool success = true; /* Init */ struct ipv6hdr *hdr6; unsigned char *payload; hdr6 = kmalloc_packet(4, NEXTHDR_UDP); if (!hdr6) return false; payload = add_payload(hdr6, HDR6_LEN); /* Test */ success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT), "Frag hdr"); success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_HOP), "Hop-by-hop hdr"); success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ESP), "ESP hdr"); success &= ASSERT_PTR(hdr6 + 1, hdr_iterator_find(hdr6, NEXTHDR_UDP), "Payload"); /* End */ kfree(hdr6); return success; }
static bool test_next_subheaders(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; struct frag_hdr *hdr_frag; struct ipv6_opt_hdr *hdr_hop; struct ipv6_opt_hdr *hdr_route; unsigned char *payload; hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4, NEXTHDR_FRAGMENT); if (!hdr6) return false; hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP); hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING); hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP); payload = add_payload(hdr_route, ROUTE_HDR_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:data"); success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type, "Frag:type"); if (!success) goto end; success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1"); success &= ASSERT_PTR(hdr_hop, iterator.data, "Hop:data"); success &= ASSERT_UINT(NEXTHDR_HOP, iterator.hdr_type, "Hop:type"); if (!success) goto end; success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 2"); success &= ASSERT_PTR(hdr_route, iterator.data, "Routing:data"); success &= ASSERT_UINT(NEXTHDR_ROUTING, iterator.hdr_type, "Routing:type"); if (!success) goto end; success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 3"); success &= ASSERT_PTR(payload, iterator.data, "Payload1:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type"); if (!success) goto end; success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 4"); success &= ASSERT_PTR(payload, iterator.data, "Payload2:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type"); /* Fall through. */ end: kfree(hdr6); return success; }
void SymbolCheckVisitor::visit(ASTSuper& ast) { ASSERT_PTR(mpClass); ASSERT_PTR(mpFunction); if ( mpClass->hasBaseType() && mpClass->getBaseType().isUnknown() ) { // skip calls to the unknown super class return; } if ( mpFunction->getModifiers().isStatic() ) { // statics do not have a this (thus also not a super) String str = ast.getKind() == ASTSuper::eThis ? UTEXT("this") : UTEXT("super"); error(E0031, UTEXT("Can not access ") + str + UTEXT(" from a static function."), ast); return; } ASTClass* pclass = ast.isThis() ? mpClass : &mpClass->getBaseClass(); if ( ast.isCall() ) { ASTSignature signature; ASTNodes& arguments = ast.getArguments(); for ( int index = 0; index < arguments.size(); index++ ) { ASTExpression& expr = dynamic_cast<ASTExpression&>(arguments[index]); expr.accept(*this); signature.append(mCurrentType.clone()); } ASTTypeList types; ASTFunction* pconstructor = pclass->findBestMatch(pclass->getName(), signature, types); if ( pconstructor != NULL ) { ast.setConstructor(pconstructor); } else { String arguments = String("(") + signature.toString() + ')'; error(E0032, UTEXT("No constructor ") + pclass->getFullName() + arguments + UTEXT(" defined."), ast); } // calls to this and super return nothing (void) mCurrentType = ASTType::SVoidType; } else { // note: pclass already is correct class for this or super mCurrentType.setKind(ASTType::eObject); mCurrentType.setObjectName(pclass->getFullName()); mCurrentType.setObjectClass(*pclass); } }
static bool test_add_and_remove(void) { struct rb_root root = RB_ROOT; struct node_thing nodes[4]; bool expecteds[4]; int i; struct node_thing *exists; bool success = true; for (i = 0; i < ARRAY_SIZE(nodes); i++) { nodes[i].i = i; RB_CLEAR_NODE(&nodes[i].hook); expecteds[i] = false; } exists = add(&root, &nodes[1]); success &= ASSERT_PTR(NULL, exists, "exists 1"); expecteds[1] = true; success &= check_nodes(&root, expecteds); if (!success) return false; exists = add(&root, &nodes[3]); success &= ASSERT_PTR(NULL, exists, "exists 2"); expecteds[3] = true; success &= check_nodes(&root, expecteds); if (!success) return false; exists = add(&root, &nodes[0]); success &= ASSERT_PTR(NULL, exists, "exists 3"); expecteds[0] = true; success &= check_nodes(&root, expecteds); if (!success) return false; exists = add(&root, &nodes[2]); success &= ASSERT_PTR(NULL, exists, "exists 4"); expecteds[2] = true; success &= check_nodes(&root, expecteds); rb_erase(&nodes[2].hook, &root); expecteds[2] = false; success &= check_nodes(&root, expecteds); if (!success) return false; return success; }
static bool test_last_unsupported(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; struct frag_hdr *hdr_frag; struct ipv6_opt_hdr *hdr_esp; struct ipv6_opt_hdr *hdr_route; unsigned char *payload; hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4, NEXTHDR_FRAGMENT); if (!hdr6) return false; hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP); hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN); hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP); payload = add_payload(hdr_route, ROUTE_HDR_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); hdr_iterator_last(&iterator); success &= ASSERT_PTR(hdr_esp, iterator.data, "Last:data"); success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "Last:type"); /* End */ kfree(hdr6); return success; }
void SymbolCheckVisitor::visit(ASTFunction& ast) { ScopedScope scope(mScopeStack); ScopedValue<ASTFunction*> scopedfunction(&mpFunction, &ast, mpFunction); ASSERT_PTR(mpFunction); visitChildren(ast); // <-- arguments if ( ast.isConstructor() && ast.getName() != mpClass->getName() ) { error(E0005, UTEXT("Function ") + ast.getName() + UTEXT(" must have a return type (or equal class name as constructor)."), ast); } if ( ast.hasBody() ) { if ( ast.getModifiers().isAbstract() ) { error(E0006, UTEXT("Abstract function ") + ast.getName() + UTEXT(" should not have a body."), ast); } else { checkReturn(ast); ast.getBody().accept(*this); } } else if ( !ast.getModifiers().isAbstract() && !ast.getModifiers().isPureNative() ) { error(E0007, UTEXT("Function ") + ast.getName() + UTEXT(" requires a body."), ast); } mCurrentType.clear(); }
/// \fn ResourceManager::loadTexture (const std::string& file) /// \brief Returns a texture from a the given file. TexturePtr ResourceManager::getTexture(const String& file) { ResourceHandle<Graphics::Texture>* phandle = NULL; if ( !mResources.contains(file) ) { String path = sPath + file; std::unique_ptr<Graphics::Texture> texture(mContentManager.loadContent<Graphics::Texture>(path)); if ( !(texture) ) return TexturePtr(); phandle = new ResourceHandle<Graphics::Texture>(*this, texture.release()); phandle->setName(file); ResourceHandleBase* pbasehandle = phandle; // needed for *& in container, perhaps time to change that.. mResources.insert(file, pbasehandle); } else { phandle = static_cast<ResourceHandle<Graphics::Texture>*>(*mResources.get(file)); } ASSERT_PTR(phandle); return TexturePtr(phandle); }
VirtualArray* CPU::instantiateArray() { ASSERT_PTR(mpArrayClass); VirtualArray* parray = new VirtualArray(); mGC.collect(parray); return parray; }
void VirtualObject::setMember(int index, const VirtualValue& value) { ASSERT_PTR(mpMembers); ASSERT(index < mMemberCount); mpMembers[index] = value; }
void IRGenerator::buildTableBlocks(VirtualLookupTable& table) { Block& block_end = createBlock(table.getEnd()); block_end.plookup = &table; block_end.lookup_type = Block::eEnd; if ( table.hasDefault() ) { Block& block_default = createBlock(table.getDefault()); block_default.plookup = &table; block_default.lookup_type = Block::eDefault; } std::vector<int> values = table.getPositions(); for ( std::size_t index = 0; index < values.size(); ++index ) { int pos = values[index]; const VirtualValue* pvalue = table.lookup(pos); ASSERT_PTR(pvalue); Block& block_case = createBlock(pos); block_case.plookup = &table; block_case.lookup_type = Block::eValue; block_case.lookup_value = *pvalue; } }
void session_delete(struct session *session) { /* Tell the other side */ ASSERT_PTR(session); ASSERT_PTR(session->server); ASSERT_PTR(session->server->owner); assert(is_thread(session->server)); pd_release_clist(session->server->owner, session->clist); session_p_list_delete(session->owner_node); session_p_list_delete(session->server_node); session_p_list_delete(session->client_node); /* Then nuke everything */ session->magic = 0; free(session); }
static bool test_next_unsupported(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; struct frag_hdr *hdr_frag; struct ipv6_opt_hdr *hdr_esp; struct ipv6_opt_hdr *hdr_route; unsigned char *payload; hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4, NEXTHDR_FRAGMENT); if (!hdr6) return false; hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP); hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN); hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP); payload = add_payload(hdr_route, ROUTE_HDR_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:pointer"); success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type, "Frag:type"); if (!success) goto end; success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1"); success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP1:pointer"); success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP1:type"); if (!success) goto end; success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 2"); success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP2:pointer"); success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP2:type"); /* Fall through. */ end: kfree(hdr6); return success; }
Module& Module::lookupModule(const Uuid& uuid) { ASSERT_PTR(mpManager); Module* pmodule = mpManager->lookup(uuid); if ( pmodule == NULL ) { throw new std::exception(); } return *pmodule; }
/** * Same as above, the only difference is that we set NULL the mtu_plateaus from * the local translate config. */ static bool translate_nulls_mtu(void) { int error; unsigned char *buffer; size_t buffer_len; bool success = true; struct global_config config = { .mtu_plateaus = NULL }; struct global_config response = { .mtu_plateaus = NULL }; error = config_clone(&config); if (error) return false; /* * lets modify our local config manually, jool's update functions wont * update to null */ config.mtu_plateaus = NULL; config.mtu_plateau_count = 0; error = serialize_global_config(&config, true, &buffer, &buffer_len); if (error) return false; error = deserialize_global_config(buffer, buffer_len, &response); if (error) return false; success &= compare_global_configs(&config, &response); /* the "compare_global_configs" will not evaluate the mtu_plateaus * because of the plateau_count = 0 */ success &= ASSERT_PTR(NULL, config.mtu_plateaus, "local config mtu_plateaus"); success &= ASSERT_PTR(NULL, response.mtu_plateaus, "deserialized config mtu_plateaus"); kfree(buffer); return success; }
void SymbolCheckVisitor::visit(ASTNative& ast) { if ( ast.hasArguments() ) { ASSERT_PTR(mpFunction); const ASTSignature& signature = mpFunction->getSignature(); ASTNodes& arguments = ast.getArguments(); for ( int index = 0; index < arguments.size(); index++ ) { ASTExpression& expr = dynamic_cast<ASTExpression&>(arguments[index]); expr.accept(*this); const ASTType& sigtype = signature[index]; if ( !mCurrentType.greater(sigtype) ) { String sidx; NumberConverter::getInstance().format(sidx, index); String func = mpClass->getFullName() + '.' + mpFunction->getName(); error(E0033, UTEXT("While calling native implementation of function ") + func + UTEXT("; argument ") + sidx + UTEXT(" of can not be mapped from ") + mCurrentType.toString() + UTEXT(" to ") + sigtype.toString(), ast); } } ASTTypeList types; if ( !mpFunction->getSignature().bestMatch(signature, types) ) { String arguments = signature.toString(); error(E0034, UTEXT("Arguments to native do not match ") + arguments, ast); } } ASSERT_PTR(mpFunction); mCurrentType = mpFunction->getType(); }
const String& IniFile::get(const String& section, const String& name) { auto it = mSections.find(section); if ( it == mSections.end() ) { throw new IniFileException(UTEXT("Section ") + name + UTEXT(" could not be found.")); } IniFileSection* psection = it->second; ASSERT_PTR(psection); return psection->get(name); }
bool ElementExecutor::execute(const Data& data) { ASSERT_PTR(data.element.get()); const std::string elem_type = data.element->elementType(); if (elem_type == "SimpleTextElement") { return executeSimpleText(data); } LOG_ERROR("Unknown element type, cannot be executed: %s", elem_type.c_str()); return false; }
static bool test_find_subheaders(void) { bool success = true; /* Init */ struct ipv6hdr *hdr6; struct frag_hdr *hdr_frag; struct ipv6_opt_hdr *hdr_hop; struct ipv6_opt_hdr *hdr_route; unsigned char *payload; hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4, NEXTHDR_FRAGMENT); if (!hdr6) return false; hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP); hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING); hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP); payload = add_payload(hdr_route, ROUTE_HDR_LEN); /* Test */ success &= ASSERT_PTR(hdr_frag, hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT), "Frag hdr"); success &= ASSERT_PTR(hdr_hop, hdr_iterator_find(hdr6, NEXTHDR_HOP), "Hop-by-hop hdr"); success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ESP), "ESP hdr"); success &= ASSERT_PTR(hdr_route, hdr_iterator_find(hdr6, NEXTHDR_ROUTING), "Routing hdr"); success &= ASSERT_PTR(payload, hdr_iterator_find(hdr6, NEXTHDR_UDP), "Payload"); /* End */ kfree(hdr6); return success; }
static bool test_next_no_subheaders(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; unsigned char *payload; hdr6 = kmalloc_packet(4, NEXTHDR_UDP); if (!hdr6) return false; payload = add_payload(hdr6, HDR6_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); success &= ASSERT_PTR(payload, iterator.data, "Payload1:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type"); if (!success) goto end; success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result1"); success &= ASSERT_PTR(payload, iterator.data, "Payload2:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type"); if (!success) goto end; success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result2"); success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result3"); success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result4"); success &= ASSERT_PTR(payload, iterator.data, "Payload3:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload3:type"); /* Fall through. */ end: kfree(hdr6); return success; }
/// \fn NetConnection::findOrCreate(const NetAddress& client) /// \brief Finds or creates an address based on the given client info /// \return the clientid of the client or INVALID_CLIENTID when not found (e.g. when not accepting) NetAddress& NetConnection::findOrCreate(const NetAddress& client) { NetAddress* pclient = mClients.find(client); if ( pclient == NULL ) { if ( IS_SET(mFlags, eAccept) ) { pclient = &addNewClient(client); } } ASSERT_PTR(pclient); return *pclient; }
static bool test_find_unsupported(void) { bool success = true; /* Init */ struct ipv6hdr *hdr6; struct frag_hdr *hdr_frag; struct ipv6_opt_hdr *hdr_esp; struct ipv6_opt_hdr *hdr_route; unsigned char *payload; hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4, NEXTHDR_FRAGMENT); if (!hdr6) return false; hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP); hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN); hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP); payload = add_payload(hdr_route, ROUTE_HDR_LEN); /* Test */ success &= ASSERT_PTR(hdr_frag, hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT), "Frag hdr"); success &= ASSERT_PTR(hdr_esp, hdr_iterator_find(hdr6, NEXTHDR_ESP), "ESP header"); /* The ESP header is in the way. */ success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ROUTING), "Routing header"); /* Same, but that isn't an extension header anyway. */ success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_UDP), "Payload"); /* End */ kfree(hdr6); return success; }
/*---------------------------------------------------------------------- * Routine silo_Read * * Purpose * * Read the requested variable from the specified DB. * *--------------------------------------------------------------------*/ INTERNAL int silo_Read (int dbid, char *varname, void *ptr) { ASSERT_NAME(varname, 0); ASSERT_PTR(ptr, 0); ASSERT_DBID(dbid, 0); if (lite_PD_read(silo_table[dbid].pdbfile, varname, ptr) == 0) { silo_Error("Cannot read requested variable.", SILO_DEBUG); return (OOPS); } return (OKAY); }
EntityDefinitionProto* EntityLoader::loadDefinition(const TiXmlElement& entity) { EntityDefinitionProto* pentitydef = new EntityDefinitionProto(); const char* pname = entity.Attribute("name"); pentitydef->mName = String::fromUtf8(pname); const char* pclasstype = entity.Attribute("class"); pentitydef->mClassName = (pclasstype != NULL ? String::fromUtf8(pclasstype) : UTEXT("engine.game.Entity")); for ( const TiXmlElement* pelement = entity.FirstChildElement(); pelement != NULL; pelement = pelement->NextSiblingElement() ) { String name = String::fromUtf8(pelement->Value()); if ( name == sChild ) { loadChildDefinition(*pentitydef, *pelement); } else if ( name == sLink ) { loadLinkDefinition(*pentitydef, *pelement); } else if ( name == sEntity ) { EntityDefinitionProto* pentity = loadDefinition(*pelement); pentitydef->mEntities.push_back(pentity); } else { Loaders::iterator it = mLoaders.find(name); if ( it != mLoaders.end() ) { ComponentLoader* ploader = it->second; ASSERT_PTR(ploader); ComponentDefinitionProto* pdefinition = ploader->load(*pelement); if ( pdefinition == NULL ) { // throw and error! } pentitydef->mComponents.push_back(pdefinition); } } } return pentitydef; }
void Console::warning(const char* msg, ...) { //ASSERT_MSG(lines, "ERROR - the console has not been created yet."); ASSERT_PTR(msg); char text[256]; va_list ap; va_start(ap, msg); vsprintf(text, msg, ap); va_end(ap); std::string errormsg = "WARNING - "; errormsg += text; //lines->addString(errormsg.c_str()); Log::getInstance() << errormsg.c_str() << '\n'; }
void CollisionContact::prepare(float timestep) { if ( mpLeft == NULL ) mpLeft = mpRight; ASSERT_PTR(mpLeft); mpLeft->prepare(mPoint); if ( mpRight != NULL ) mpRight->prepare(mPoint); calculateContactBasis(); mContactVelocity = calculateLocalVelocity(*mpLeft, timestep); if ( mpRight != NULL ) mContactVelocity -= calculateLocalVelocity(*mpRight, timestep); calculateDesiredDeltaVelocity(timestep); }
void OOCheckVisitor::visit(ASTClass& ast) { mpClass = * ASSERT_PTR(mpClass); if ( mpClass->isClass() ) { if ( mpClass->hasAbstractFunction() ) { if ( !ast.getModifiers().isAbstract() ) { error(E0052, UTEXT("Class ") + mpClass->getName() + UTEXT(" must be defined as abstract."), ast); } } if ( ast.hasBaseClass() && ast.getBaseClass().getModifiers().isFinal() ) { error(E0053, UTEXT("Class ") + ast.getName() + UTEXT(" can not extend final class ") + ast.getBaseClass().getName(), ast); } if ( ast.getModifiers().isAbstract() && !mpClass->hasAbstractFunction() ) { warning(W0004, UTEXT("Class ") + ast.getName() + UTEXT(" is marked abstract without abstract functions."), ast); } } else { ASSERT(mpClass->isInterface()); } if ( ast.isNative() ) { // a class is native if its either marked native or has one or native functions ast.getModifiers().setNative(); } validateClass(ast); visitChildren(ast); }
Glyph* D3DGlyphProvider::getGlyph(UChar ch, float emsize) { HRESULT hr = S_OK; IDWriteTextLayout* ptextlayout = NULL; ASSERT_PTR(mpTextFormat); hr = mpDWriteFactory->CreateTextLayout(&ch, 1, mpTextFormat, 512, 512, &ptextlayout); if ( SUCCEEDED(hr) ) { DWRITE_TEXT_RANGE range = { 0, 0 }; ptextlayout->SetFontSize(emsize, range); AutoPtr<Glyph> glyph = new Glyph(); hr = ptextlayout->Draw(glyph.getPointer(), mpTextRenderer, 0, 0); if ( SUCCEEDED(hr) ) { return glyph.release(); } } return NULL; }
static bool test_last_no_subheaders(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; unsigned char *payload; hdr6 = kmalloc_packet(4, NEXTHDR_UDP); if (!hdr6) return false; payload = add_payload(hdr6, HDR6_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); hdr_iterator_last(&iterator); success &= ASSERT_PTR(payload, iterator.data, "Last:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Last:type"); /* End */ kfree(hdr6); return success; }
const VirtualClass& VirtualFunction::getClass() const { ASSERT_PTR(mpClass); return *mpClass; }
ASTType& ASTType::getArrayType() { ASSERT(isArray()); ASSERT_PTR(mpArrayType); return *mpArrayType; }