int main() { int a = 5; int b = 10; int c = 20; List* list = list_create(); Iterator* iterator = list_iterator(list); assert(false == iterator_has_next(iterator)); iterator_destroy(iterator); list_push(list, &a); list_push(list, &b); list_push(list, &c); iterator = list_iterator(list); assert(true == iterator_has_next(iterator)); assert(&a == iterator_next(iterator)); assert(&b == iterator_next(iterator)); assert(&c == iterator_next(iterator)); assert(false == iterator_has_next(iterator)); iterator_destroy(iterator); return 0; }
io_library_t *__io_storeLibraryWithAddress(vm_address_t address) { if(spinlock_tryLock(&__io_storeLock)) { iterator_t *iterator = atree_iterator(__io_storeLibraries); io_library_t *library; while((library = iterator_nextObject(iterator))) { vm_address_t vlimit = library->vmemory + (library->pages * VM_PAGE_SIZE); if(address >= library->vmemory && address <= vlimit) { iterator_destroy(iterator); spinlock_unlock(&__io_storeLock); return library; } } iterator_destroy(iterator); spinlock_unlock(&__io_storeLock); } return NULL; }
void t_field_map(void) { pool_reference list_pool = pool_create(LIST_TYPE_ID); CU_ASSERT_NOT_EQUAL_FATAL(list_pool, NULL_POOL); global_reference head = pool_alloc(&list_pool); pool_iterator itr = iterator_new(&list_pool, &head); size_t list_size = 10000; for (size_t i = 0 ; i < list_size ; ++i) { iterator_set_field(itr, 1, &i); iterator_list_insert(itr, pool_alloc(&list_pool)); itr = iterator_next(list_pool, itr); } pool_reference long_pool = pool_create(LONG_TYPE_ID); CU_ASSERT_NOT_EQUAL_FATAL(long_pool, NULL_POOL); CU_ASSERT_EQUAL(field_map(list_pool, &long_pool, 1, square), 0); uint64_t *result = pool_to_array(long_pool); int cmp_error_count = 0; for (size_t i = 0 ; i < list_size ; ++i) { cmp_error_count += i*i != result[i]; } CU_ASSERT_EQUAL(cmp_error_count, 0); iterator_destroy(&itr); pool_destroy(&long_pool); pool_destroy(&list_pool); }
void test_next_nonEmptyList(void) { list_t* lista = list_init(); addElement(lista, (void*)a); addElement(lista, (void*)b); addElement(lista, (void*)c); iterator_t* i=iterator_init(lista); payload_t * corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->head->payload); corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->head->next->payload); corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->tail->payload); corrente = next(i); CU_ASSERT_PTR_NULL(corrente); iterator_destroy(i); list_destroy(lista); }
void test_next_emptyList(void) { list_t* lista = list_init(); iterator_t* it=iterator_init(lista); CU_ASSERT_PTR_NULL(next(it)); CU_ASSERT_PTR_NULL(it->currentNode); iterator_destroy(it); list_destroy(lista); }
void test_hasNext_emptyList(void) { list_t* lista = list_init(); iterator_t* i=iterator_init(lista); CU_ASSERT_EQUAL(hasNext(i), 0); iterator_destroy(i); list_destroy(lista); }
void test_hasNext_nonEmptyList(void) { list_t* lista = list_init(); addElement(lista, (void*)single); iterator_t* i=iterator_init(lista); CU_ASSERT_NOT_EQUAL(hasNext(i), 0); CU_ASSERT_PTR_EQUAL(i->currentNode, lista->head); iterator_destroy(i); list_destroy(lista); }
void test_iterator_init_destroy(void) { list_t* list = list_init(); iterator_t* i=iterator_init(list); CU_ASSERT_PTR_NOT_NULL(i); CU_ASSERT_PTR_EQUAL(i->list, list); CU_ASSERT_PTR_EQUAL(i->currentNode, list->head); iterator_destroy(i); list_destroy(list); }
//controla se un messaggio e' presente nella lista int containsValue(list_t* lista, char* name){ int test = 0; iterator_t* iterator = iterator_init(lista); while(hasNext(iterator) && !test){ reader_t* reader =((reader_t*)(iterator->currentNode->payload)); if(strcmp(reader->name, name) == 0) test = 1; next(iterator); } iterator_destroy(iterator); return test; }
int main(int argc, char* argv[]) { int i = 0; int n = 101; int last = n - 1; DList* dlist = dlist_create(NULL, NULL); for (i = 0; i < n; i++) { dlist_append(dlist, (void*)i); } Iterator* forward = dlist_iterator_create(dlist); Iterator* backward = dlist_iterator_create(dlist); iterator_advance(backward, last); invert(forward, backward); dlist_foreach(dlist, check_and_dec_int, &last); iterator_destroy(forward); iterator_destroy(backward); dlist_destroy(dlist); return 0; }
void test_iterator_init_destroy(){ Vector* vec = vector_init(1); int *a = NULL, *b = NULL, *c = NULL; vector_push_back(vec, a); vector_push_back(vec, b); vector_push_back(vec, c); Iterator* it = iterator_init(vec); assert(it->container == vec); assert(it->curent == vec->array); assert(*(it->curent) == a); iterator_destroy(it); vector_destroy(vec); }
void test_iterator_end(){ Vector* vec = vector_init(1); int a = 1, b = 2, c = 3, d = 4; vector_push_back(vec, &a); vector_push_back(vec, &b); vector_push_back(vec, &c); vector_push_back(vec, &d); Iterator* it = iterator_init(vec); assert(iterator_element(it) == &a); iterator_end(it); assert(iterator_element(it) == &d); iterator_destroy(it); vector_destroy(vec); }
void test_iterator_valid(){ Vector* vec = vector_init(1); int a = 1, b = 2, c = 3, d = 4; vector_push_back(vec, &a); vector_push_back(vec, &b); vector_push_back(vec, &c); vector_push_back(vec, &d); Iterator* it = iterator_init(vec); assert(iterator_valid(it) == 1); iterator_before(it); assert(iterator_valid(it) == 0); iterator_end(it); assert(iterator_valid(it) == 1); iterator_next(it); assert(iterator_valid(it) == 0); iterator_destroy(it); vector_destroy(vec); }
iterator_t mpi_file_ntriples_node_iterator_create(MPI_File file, MPI_Offset start, MPI_Offset amount, size_t bufsize, MPI_Comm comm) { _mpi_file_ntriples_node_iterator_state_t state = malloc(sizeof(_mpi_file_ntriples_node_iterator_state_type)); if(state == NULL) { fprintf(stderr, "%s:%u: Error in mpi_file_ntriples_node_iterator_create; unable to allocate %u bytes for internal state.\n", __FILE__, __LINE__, sizeof(_mpi_file_ntriples_node_iterator_state_type)); return NULL; } state->ntriple = NULL; state->mark = NULL; state->part = _MPI_FILE_NTRIPLES_NODE_ITERATOR_SUBJECT; state->iter = mpi_file_ntriples_iterator_create(file, start, amount, bufsize, comm); if(state->iter == NULL) { fprintf(stderr, "%s:%u: Error in mpi_file_ntriples_node_iterator_create; unable to allocate underlying iterator.\n", __FILE__, __LINE__); free(state); return NULL; } iterator_t iter = iterator_create(&_mpi_file_ntriples_node_iterator_has_next, &_mpi_file_ntriples_node_iterator_next, &_mpi_file_ntriples_node_iterator_destroy, state); if(iter == NULL) { fprintf(stderr, "%s:%u: Error in mpi_file_ntriples_node_iterator_create; unable to allocate iterator.\n", __FILE__, __LINE__); iterator_destroy(state->iter); free(state); } return iter; }
int invoke_packet_handlers(packet_t type, void *packet) { int forward = FORWARD_PACKET; packet_handler_t *handler; byte id; switch (type) { case BNCS_RECEIVED: case BNCS_SENT: id = BNCS_CAST(packet)->id; break; case MCP_RECEIVED: case MCP_SENT: id = MCP_CAST(packet)->id; break; case D2GS_RECEIVED: case D2GS_SENT: id = D2GS_CAST(packet)->id; break; case INTERNAL: id = INTERNAL_CAST(packet)->id; break; default: return forward; } struct iterator i = list_iterator(&packet_handlers[type][id]); while ((handler = iterator_next(&i))) { void *c; void *data = NULL; switch (type) { case BNCS_RECEIVED: case BNCS_SENT: c = calloc(1, sizeof(bncs_packet_t)); BNCS_CAST(c)->id = id; BNCS_CAST(c)->len = BNCS_CAST(packet)->len; if (bncs_has_payload(BNCS_CAST(packet))) { BNCS_CAST(c)->data = malloc(BNCS_CAST(packet)->len); data = BNCS_CAST(c)->data; memcpy(BNCS_CAST(c)->data, BNCS_CAST(packet)->data, BNCS_CAST(packet)->len - BNCS_HEADER_SIZE); } break; case MCP_RECEIVED: case MCP_SENT: c = calloc(1, sizeof(mcp_packet_t)); MCP_CAST(c)->id = id; MCP_CAST(c)->len = MCP_CAST(packet)->len; if (mcp_has_payload(MCP_CAST(packet))) { MCP_CAST(c)->data = malloc(MCP_CAST(packet)->len); data = MCP_CAST(c)->data; memcpy(MCP_CAST(c)->data, MCP_CAST(packet)->data, MCP_CAST(packet)->len - MCP_HEADER_SIZE); } break; case D2GS_RECEIVED: case D2GS_SENT: c = calloc(1, sizeof(d2gs_packet_t)); D2GS_CAST(c)->id = id; D2GS_CAST(c)->len = D2GS_CAST(packet)->len; if (d2gs_has_payload(D2GS_CAST(packet))) { D2GS_CAST(c)->data = malloc(D2GS_CAST(packet)->len); data = D2GS_CAST(c)->data; memcpy(D2GS_CAST(c)->data, D2GS_CAST(packet)->data, D2GS_CAST(packet)->len - D2GS_HEADER_SIZE); } break; case INTERNAL: c = calloc(1, sizeof(internal_packet_t)); INTERNAL_CAST(c)->id = id; INTERNAL_CAST(c)->len = INTERNAL_CAST(packet)->len; if (internal_has_payload(INTERNAL_CAST(packet))) { INTERNAL_CAST(c)->data = malloc(INTERNAL_CAST(packet)->len); data = INTERNAL_CAST(c)->data; memcpy(INTERNAL_CAST(c)->data, INTERNAL_CAST(packet)->data, INTERNAL_CAST(packet)->len - INTERNAL_HEADER_SIZE); } break; default: return forward; } forward = (*handler)((void *) c); free(c); if (data) { free(data); } if (forward == HIDE_PACKET || forward == BLOCK_PACKET) { iterator_destroy(&i); break; } } return forward; }
void _mpi_file_ntriples_node_iterator_destroy(void* s) { _mpi_file_ntriples_node_iterator_state_t state = (_mpi_file_ntriples_node_iterator_state_t) s; iterator_destroy(state->iter); free(state); }