bool bitmap_Contains(Bitmap *bitmap, Bitmap *other) { if (bitmap->bitSize != other->bitSize) { assertFalse(true, "Fatal error. Bitmaps were not the same size."); } for (int i = 0; i < bitmap->bitSize; i++) { if (!bitmap_Get(bitmap, i) && bitmap_Get(other, i)) { return false; } } return true; }
bool bitmap_Equals(Bitmap *bitmap, Bitmap *other) { if (bitmap->bitSize != other->bitSize) { assertFalse(true, "Fatal error. Bitmaps were not the same size: %d and %d", bitmap->bitSize, other->bitSize); } for (int i = 0; i < bitmap->bitSize; i++) { if (bitmap_Get(bitmap, i) != bitmap_Get(other, i)) { return false; } } return true; }
LONGBOW_TEST_CASE(Global, metisMessage_HasHopLimit_False) { PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); parcLogReporter_Release(&reporter); MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest_no_hoplimit, sizeof(metisTestDataV0_EncodedInterest_no_hoplimit), 1, 2, logger); metisLogger_Release(&logger); bool hasHopLimit = metisMessage_HasHopLimit(message); assertFalse(hasHopLimit, "Message without a hop limit says it does."); metisMessage_Release(&message); }
void testJSONValidator__isValidRoot::testNotRoots(void){ #ifdef JSON_VALIDATE assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{]"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[}"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{}aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[]aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT(""))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[\"stuff\":{},]"))); #endif }
LONGBOW_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentValue) { PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); parcLogReporter_Release(&reporter); MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondInterest, sizeof(metisTestDataV0_SecondInterest), 1, 2, logger); metisLogger_Release(&logger); assertFalse(metisMessage_KeyIdEquals(a, b), "Messages with differnt keyids did compared equal"); metisMessage_Release(&a); metisMessage_Release(&b); }
LONGBOW_TEST_CASE(Global, parcBitVector_Equals) { PARCBitVector *parcBitVector = parcBitVector_Create(); assertTrue(parcBitVector, "parcBitVector_Create returned a NULL pointer"); parcBitVector_Set(parcBitVector, 10); PARCBitVector *copy = parcBitVector_Copy(parcBitVector); assertTrue(parcBitVector_Equals(parcBitVector, copy), "Duplicate vector found unequal"); parcBitVector_Set(copy, 9); assertFalse(parcBitVector_Equals(parcBitVector, copy), "Unequal vector found equal"); parcBitVector_Clear(copy, 9); parcBitVector_Set(copy, 29); assertFalse(parcBitVector_Equals(parcBitVector, copy), "Unequal long vector found equal"); parcBitVector_Clear(copy, 29); assertTrue(parcBitVector_Equals(parcBitVector, copy), "Equal long vector found unequal"); assertTrue(parcBitVector_Equals(copy, parcBitVector), "Equal long vector found unequal"); parcBitVector_Release(©); parcBitVector_Release(&parcBitVector); }
LONGBOW_TEST_CASE(Global, parcCryptoHash_CreateFromArray) { int fd = open("test_digest_bytes_128.sha256", O_RDONLY); assertFalse(fd < 0, "Could not open %s: %s", "test_digest_bytes_128.sha256", strerror(errno)); uint8_t scratch[bufferLength]; ssize_t read_length = read(fd, scratch, bufferLength); PARCCryptoHash *hash = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch, read_length); assertNotNull(hash, "Expected to be non null"); parcCryptoHash_Release(&hash); close(fd); }
A_Test void FileSuffixTest_hasAsmFileSuffix(void) { assertFalse(FileSuffix_hasAsmFileSuffix("foo.c")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.i")); assertTrue(FileSuffix_hasAsmFileSuffix("foo.s")); assertTrue(FileSuffix_hasAsmFileSuffix("foo.a51")); assertTrue(FileSuffix_hasAsmFileSuffix("foo.A51")); assertTrue(FileSuffix_hasAsmFileSuffix("foo.asm")); assertTrue(FileSuffix_hasAsmFileSuffix("foo.ASM")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.o")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.a")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.obj")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.OBJ")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.lib")); assertFalse(FileSuffix_hasAsmFileSuffix("foo.LIB")); }
LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsNotEqual) { // create messages from different content objects PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); parcLogReporter_Release(&reporter); MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, sizeof(metisTestDataV0_SecondObject), 1, 2, logger); metisLogger_Release(&logger); assertFalse(metisMessage_ObjectHashEquals(a, b), "Messages with unequal ContentObjectHash compared as equal"); metisMessage_Release(&a); metisMessage_Release(&b); }
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_IsKeyName) { CCNxName *keyURIName = ccnxName_CreateFromCString("lci://name/test"); CCNxLink *keyLink = ccnxLink_Create(keyURIName, NULL, NULL); CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKeyLink(keyLink); ccnxKeyLocator_AssertValid(keyLocator); assertFalse(ccnxKeyLocator_IsKey(keyLocator), "Expected Iskey to be false"); assertTrue(ccnxKeyLocator_IsKeyLink(keyLocator), "Expected IsKeyLink to be true"); ccnxKeyLocator_Release(&keyLocator); ccnxName_Release(&keyURIName); ccnxLink_Release(&keyLink); }
static int _testCopyInvalidFileToDirectory(void) { CharString tempDir = _fileUtilitiesMakeTempDir(); CharString testFilename = newCharStringWithCString(TEST_FILENAME); CharString invalid = newCharStringWithCString("invalid"); convertRelativePathToAbsolute(testFilename, invalid); assertFalse(copyFileToDirectory(invalid, tempDir)); removeDirectory(tempDir); freeCharString(testFilename); freeCharString(tempDir); freeCharString(invalid); return 0; }
static int _testAdvanceClockMulitpleTimes(void) { AudioClock audioClock = getAudioClock(); int i; for (i = 0; i < 100; i++) { advanceAudioClock(audioClock, kAudioClockTestBlocksize); } assert(audioClock->isPlaying); assertFalse(audioClock->transportChanged); assertUnsignedLongEquals(kAudioClockTestBlocksize * 100, audioClock->currentFrame); return 0; }
void sendbuffer(int fd, struct fdstate *state) { struct sendlist *entry = parcMemory_AllocateAndClear(sizeof(struct sendlist)); assertNotNull(entry, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sendlist)); size_t len, total_len; localhdr *hdr = (localhdr *) entry->buffer; int i; ssize_t res; len = random() % (MAXSEND - sizeof(localhdr) - 1) + 1; hdr->pid = getpid(); hdr->fd = fd; hdr->length = (int) len; total_len = len + sizeof(localhdr); entry->length = total_len; entry->refcount = 0; for (i = 0; i < CONN_COUNT; i++) { if (state[i].fd != fd) { entry->refcount++; state[i].expected[ state[i].tail ] = entry; state[i].tail = (state[i].tail + 1) % MAXPENDING; state[i].count_expected++; assertFalse(state[i].tail == state[i].head, "%s buffer wrap around on fd %d", __func__, state[i].fd); if (CHATTY) { printf("conn %2d added expected cnt %u length %zu\n", i, state[i].count_expected, entry->length); } } else { state[i].count_send++; if (CHATTY) { printf("conn %2d sent count %u\n", i, state[i].count_send); } } } res = write(fd, entry->buffer, entry->length); assertTrue(res == entry->length, "%s write error %s\n", __func__, strerror(errno)); }
LONGBOW_TEST_CASE(EmptyImplementation, booleanApiFunctions) { AthenaContentStore *store = athenaContentStore_Create(&EmptyContentStoreImplementation, NULL); CCNxContentObject *contentObject = _createContentObject("lci:/dogs/are/better/than/cats", 10, NULL); CCNxName *name = ccnxName_CreateFromURI("lci:/pie/is/always/good"); CCNxInterest *interest = ccnxInterest_CreateSimple(name); //athena_EncodeMessage(interest); AthenaContentStore *ref = athenaContentStore_Acquire(store); athenaContentStore_Release(&ref); assertFalse(athenaContentStore_PutContentObject(store, contentObject), "Expected false from PutContentObject"); assertFalse(athenaContentStore_GetMatch(store, interest), "Expected false from GetMatch"); assertFalse(athenaContentStore_SetCapacity(store, 1), "Expected false from SetCapacity"); assertFalse(athenaContentStore_RemoveMatch(store, name, NULL, NULL), "Expected false from RemoveMatch"); ccnxName_Release(&name); ccnxInterest_Release(&interest); ccnxContentObject_Release(&contentObject); athenaContentStore_Release(&store); }
LONGBOW_TEST_CASE(Global, rtaApiConnection_SendToApi) { TestData *data = longBowTestCase_GetClipBoardData(testCase); RtaApiConnection *apiConnection = rtaConnection_GetPrivateData(data->connection, API_CONNECTOR); TransportMessage *tm = trafficTools_CreateTransportMessageWithDictionaryInterest(data->connection, CCNxTlvDictionary_SchemaVersion_V1); RtaComponentStats *stats = rtaConnection_GetStats(data->connection, API_CONNECTOR); rtaApiConnection_SendToApi(apiConnection, tm, stats); rtaFramework_NonThreadedStepCount(data->framework, 10); // Let the dispatcher run struct pollfd pfd = { .fd = data->api_fds[PAIR_OTHER], .events = POLLIN, .revents = 0 }; int millisecondTimeout = 1000; int pollvalue = poll(&pfd, 1, millisecondTimeout); assertTrue(pollvalue == 1, "Did not get an event from the API's side of the socket"); CCNxMetaMessage *testMessage; ssize_t bytesRead = read(data->api_fds[PAIR_OTHER], &testMessage, sizeof(testMessage)); assertTrue(bytesRead == sizeof(testMessage), "Wrong read size, got %zd expected %zd: (%d) %s", bytesRead, sizeof(testMessage), errno, strerror(errno)); assertNotNull(testMessage, "Message read is NULL"); assertTrue(testMessage == transportMessage_GetDictionary(tm), "Got wrong raw message, got %p expected %p", (void *) testMessage, (void *) transportMessage_GetDictionary(tm)); ccnxMetaMessage_Release(&testMessage); transportMessage_Destroy(&tm); } LONGBOW_TEST_CASE(Global, rtaApiConnection_BlockDown) { TestData *data = longBowTestCase_GetClipBoardData(testCase); RtaApiConnection *apiConnection = rtaApiConnection_Create(data->connection); // make sure we're startined unblocked short enabled = parcEventQueue_GetEnabled(apiConnection->bev_api); assertTrue(enabled & PARCEventType_Read, "PARCEventType_Read is not enabled on a new Api Connector: enabled = %04X", enabled); rtaApiConnection_BlockDown(apiConnection); enabled = parcEventQueue_GetEnabled(apiConnection->bev_api); assertFalse(enabled & PARCEventType_Read, "PARCEventType_Read is still enabled after caling BlockDown: enabled = %04X", enabled); rtaApiConnection_Destroy(&apiConnection); }
static void _parcObjectTesting_AssertCopy(const PARCObject *instance) { PARCObject *copy = parcObject_Copy(instance); if (copy == instance) { parcObject_Release(©); assertFalse(true, "Copy should not be the same object"); } if (!parcObject_Equals(instance, copy)) { parcObject_Release(©); assertTrue(false, "Object fails Copy Test"); } parcObject_Release(©); }
LONGBOW_TEST_CASE(Global, cpiAck_CreateNack) { CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar"); CPIRouteEntry *route = cpiRouteEntry_CreateRouteToSelf(name); PARCJSON *request = cpiForwarding_CreateAddRouteRequest(route); PARCJSON *actual = cpiAcks_CreateNack(request); assertFalse(cpiAcks_IsAck(actual), "Expected cpiAcks_IsAck to return false."); parcJSON_Release(&actual); parcJSON_Release(&request); cpiRouteEntry_Destroy(&route); ccnxName_Release(&name); }
PARCBuffer * parcBuffer_SetPosition(PARCBuffer *buffer, size_t newPosition) { parcBuffer_OptionalAssertValid(buffer); assertFalse(newPosition > buffer->limit, "new position cannot be greater the buffer's limit"); buffer->position = newPosition; if (!_markIsDiscarded(buffer) && newPosition < buffer->mark) { _discardMark(buffer); } _optionalAssertInvariants(buffer); return buffer; }
void testLiteral() { tryLiteralOk("true ", [](const JSONAtom &atom) { assertTrue(atom.asBool()); }); tryLiteralOk("false ", [](const JSONAtom &atom) { assertFalse(atom.asBool()); }); tryLiteralOk("null ", [](const JSONAtom &atom) { assertNull(atom.asNull()); }); const char *const json = "invalid "; memoryStream_t stream(const_cast<char *const>(json), length(json)); JSONParser parser(stream); try { std::unique_ptr<JSONAtom> atom(literal(parser)); fail("The parser failed to throw an exception on invalid literal"); } catch (const JSONParserError &err) { } }
LONGBOW_TEST_CASE(Global, ccnxContentObject_HasExpiryTime) { CCNxName *name = ccnxName_CreateFromCString("lci:/hello/dolly"); PARCBuffer *payload = parcBuffer_WrapCString("hello"); // Use a V1 ContentObject, as V0 doesn't support ExpiryTime CCNxContentObject *contentObject = ccnxContentObject_CreateWithImplAndPayload(&CCNxContentObjectFacadeV1_Implementation, name, CCNxPayloadType_DATA, payload); assertFalse(ccnxContentObject_HasExpiryTime(contentObject), "Expected no expiration time by default"); parcBuffer_Release(&payload); ccnxName_Release(&name); ccnxContentObject_Release(&contentObject); }
LONGBOW_TEST_CASE(Global, ccnxContentObject_HasFinalChunkNumber) { CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar"); PARCBuffer *payload = parcBuffer_Allocate(100); CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload); assertFalse(ccnxContentObject_HasFinalChunkNumber(contentObject), "Expected no final chunk number"); ccnxContentObject_SetFinalChunkNumber(contentObject, 100); ccnxContentObject_AssertValid(contentObject); assertTrue(ccnxContentObject_HasFinalChunkNumber(contentObject), "Expected HasFinalChunkNumber to return true"); assertTrue(ccnxContentObject_GetFinalChunkNumber(contentObject) == 100, "Expected final chunk number to be 100"); ccnxName_Release(&name); parcBuffer_Release(&payload); ccnxContentObject_Release(&contentObject); }
static int _testCopyFileToInvalidDirectory(void) { CharString tempFile = newCharString(); CharString testFilename = newCharStringWithCString(TEST_FILENAME); CharString invalid = newCharStringWithCString("invalid"); FILE *fp = fopen(TEST_FILENAME, "w"); assertNotNull(fp); fclose(fp); convertRelativePathToAbsolute(testFilename, tempFile); assertFalse(copyFileToDirectory(tempFile, invalid)); unlink(TEST_FILENAME); freeCharString(tempFile); freeCharString(testFilename); freeCharString(invalid); return 0; }
void testJSONValidator__isValidRoot::testSuddenEnd(void){ #ifdef JSON_VALIDATE assertFalse(JSONValidator::isValidRoot(JSON_TEXT(""))); //--- void testJSONValidator__isValidRoot::testRoots(void){ assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("["))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[\"stuff"))); //---void testJSONValidator__isValidRoot::testNotRoots(void){ assertFalse(JSONValidator::isValidRoot(JSON_TEXT("{}aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("[]aoe"))); assertFalse(JSONValidator::isValidRoot(JSON_TEXT("aoe"))); #endif }
static void recursiveDelete(const char *path) { // only allow under tmp assertTrue(strncmp(path, "/tmp/", 5) == 0, "Path must begin with /tmp/: %s", path); // dont allow ".." assertNull(strstr(path, ".."), "Path cannot have .. in it: %s", path); // depth first, dont't follow symlinks int flags = FTW_DEPTH | FTW_PHYS; // maximum 20 fds open at a time int max_fd = 20; int failure = nftw(path, deleteEntry, max_fd, flags); assertFalse(failure, "Error on recursive delete: (%d) %s", errno, strerror(errno)); }
LONGBOW_TEST_CASE(Global, parcBitVector_Contains) { PARCBitVector *supersetVector = parcBitVector_Create(); parcBitVector_Set(supersetVector, 10); parcBitVector_Set(supersetVector, 11); PARCBitVector *testVector = parcBitVector_Create(); parcBitVector_Set(testVector, 10); assertTrue(parcBitVector_Contains(supersetVector, testVector), "Expect superset to contain testVector"); parcBitVector_Set(testVector, 12); assertFalse(parcBitVector_Contains(supersetVector, testVector), "Expect superset to not contain testVector"); parcBitVector_Release(&supersetVector); parcBitVector_Release(&testVector); }
static CCNxMetaMessage * _athenaLRUContentStore_ProcessMessage(AthenaContentStoreImplementation *store, const CCNxMetaMessage *message) { CCNxMetaMessage *result = NULL; AthenaLRUContentStore *impl = (AthenaLRUContentStore *) store; if (ccnxMetaMessage_IsInterest(message)) { CCNxInterest *interest = ccnxMetaMessage_GetInterest(message); CCNxName *queryName = ccnxInterest_GetName(interest); uint64_t chunkNumber = 0; bool hasChunkNumber = false; _getChunkNumberFromName(queryName, &chunkNumber, &hasChunkNumber); assertFalse(hasChunkNumber, "LRUContentStore queries don't yet support more than 1 chunk."); PARCBuffer *responsePayload = NULL; // Find the arguments to our query. size_t argSegmentIndex = 0; if (_getSegmentIndexOfQueryArgs(queryName, AthenaModule_ContentStore, &argSegmentIndex)) { CCNxNameSegment *queryTypeSegment = ccnxName_GetSegment(queryName, argSegmentIndex); char *queryTypeString = ccnxNameSegment_ToString(queryTypeSegment); // e.g. "stat" char *statString = "stat"; if (strncasecmp(queryTypeString, statString, strlen(statString)) == 0) { responsePayload = _processStatQuery(impl, queryName, argSegmentIndex + 1, chunkNumber); } parcMemory_Deallocate(&queryTypeString); } if (responsePayload != NULL) { CCNxContentObject *contentObjectResponse = ccnxContentObject_CreateWithNameAndPayload( ccnxInterest_GetName(interest), responsePayload); result = ccnxMetaMessage_CreateFromContentObject(contentObjectResponse); ccnxContentObject_SetExpiryTime(contentObjectResponse, parcClock_GetTime(impl->wallClock) + 100); // this response is good for 100 millis ccnxContentObject_Release(&contentObjectResponse); parcBuffer_Release(&responsePayload); } } return result; // could be NULL }
LONGBOW_TEST_CASE(Global, cpiAddress_Equals_NotEqual) { struct sockaddr_in addr_in; memset(&addr_in, 0, sizeof(struct sockaddr_in)); addr_in.sin_addr.s_addr = 0x01020304; addr_in.sin_family = AF_INET; addr_in.sin_port = 0x0A0B; CPIAddress *a = cpiAddress_CreateFromInet(&addr_in); CPIAddress *b = cpiAddress_CreateFromInterface(1); assertFalse(cpiAddress_Equals(a, b), "Equals failed on different addresses: %s and %s", cpiAddress_ToString(a), cpiAddress_ToString(b)); cpiAddress_Destroy(&a); cpiAddress_Destroy(&b); }
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_IsKey) { char *hexString = "ABCDEF1234"; PARCBuffer *keyBuffer = parcBuffer_WrapCString(hexString); PARCKeyId *keyId = parcKeyId_Create(keyBuffer); PARCKey *key = parcKey_CreateFromDerEncodedPublicKey(keyId, PARCSigningAlgorithm_RSA, keyBuffer); CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKey(key); parcKeyId_Release(&keyId); parcBuffer_Release(&keyBuffer); ccnxKeyLocator_AssertValid(keyLocator); assertTrue(ccnxKeyLocator_IsKey(keyLocator), "Expected Iskey to be true"); assertFalse(ccnxKeyLocator_IsKeyLink(keyLocator), "Expected IsKeyLink to be false"); ccnxKeyLocator_Release(&keyLocator); parcKey_Release(&key); }
LONGBOW_TEST_CASE(Global, athenaTransportLinkModuleUDP_Local) { PARCURI *connectionURI; const char *result; AthenaTransportLinkAdapter *athenaTransportLinkAdapter = athenaTransportLinkAdapter_Create(_removeLink, NULL); assertNotNull(athenaTransportLinkAdapter, "athenaTransportLinkAdapter_Create returned NULL"); connectionURI = parcURI_Parse("udp://127.0.0.1:40000/Listener/name=UDP_0"); result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI); assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno)); parcURI_Release(&connectionURI); connectionURI = parcURI_Parse("udp://127.0.0.1:40000/name=UDP_1/local=boo"); result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI); assertTrue(result == NULL, "athenaTransportLinkAdapter_Open failed to detect bad local directive"); parcURI_Release(&connectionURI); connectionURI = parcURI_Parse("udp://127.0.0.1:40000/name=UDP_1/local=true"); result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI); assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno)); parcURI_Release(&connectionURI); connectionURI = parcURI_Parse("udp://127.0.0.1:40000/name=UDP_2/local=false"); result = athenaTransportLinkAdapter_Open(athenaTransportLinkAdapter, connectionURI); assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno)); parcURI_Release(&connectionURI); int linkId = athenaTransportLinkAdapter_LinkNameToId(athenaTransportLinkAdapter, "UDP_1"); assertFalse(athenaTransportLinkAdapter_IsNotLocal(athenaTransportLinkAdapter, linkId), "Local connection not local"); linkId = athenaTransportLinkAdapter_LinkNameToId(athenaTransportLinkAdapter, "UDP_2"); assertTrue(athenaTransportLinkAdapter_IsNotLocal(athenaTransportLinkAdapter, linkId), "NonLocal connection is local"); int closeResult = athenaTransportLinkAdapter_CloseByName(athenaTransportLinkAdapter, "UDP_2"); assertTrue(closeResult == 0, "athenaTransportLinkAdapter_CloseByName failed (%s)", strerror(errno)); closeResult = athenaTransportLinkAdapter_CloseByName(athenaTransportLinkAdapter, "UDP_1"); assertTrue(closeResult == 0, "athenaTransportLinkAdapter_CloseByName failed (%s)", strerror(errno)); closeResult = athenaTransportLinkAdapter_CloseByName(athenaTransportLinkAdapter, "UDP_0"); assertTrue(closeResult == 0, "athenaTransportLinkAdapter_CloseByName failed (%s)", strerror(errno)); athenaTransportLinkAdapter_Destroy(&athenaTransportLinkAdapter); }
/* * Runs the test case. */ void runTest() { Document doc; NodeList addressList; Node testNode; NamedNodeMap attributes; Attr streetAttr; boolean state; doc = (Document) baseT::load("staff", true); addressList = doc.getElementsByTagName(SA::construct_from_utf8("address")); testNode = addressList.item(2); ((Element) /*Node */testNode).removeAttribute(SA::construct_from_utf8("street")); attributes = testNode.getAttributes(); streetAttr = (Attr) attributes.getNamedItem(SA::construct_from_utf8("street")); baseT::skipIfNull(streetAttr); state = streetAttr.getSpecified(); assertFalse(state); }