static void recv_uc(struct unicast_conn *c, const rimeaddr_t *from) { printf("unicast message received from %x.%x: '%s'\n", from->u8[0], from->u8[1], (char *) packetbuf_dataptr()); sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); printf("packet: %s\n buff: %s\n",(char *) packetbuf_dataptr(), buff_); if(strcmp((char *) packetbuf_dataptr(), buff_) == 0){ static rimeaddr_t addr; addr.u8[0] = 2 & 0xFF; addr.u8[1] = 0 >> 8; static int8_t idx = 0; char buff_[30] = {'\0'}; sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); packetbuf_copyfrom(buff_ , NET_TEST_CFG_REQUEST_MSG_LEN); unicast_send(&uc, &addr); printf("send: %s\n",buff_); rec_count++; TEST_PASS(); } // check if done if (rec_count == 10) { rec_count=0; } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(rime_unicast_sender, ev, data) { PROCESS_EXITHANDLER(unicast_close(&uc)); PROCESS_BEGIN(); TEST_PASS(); unicast_open(&uc, 146, &unicast_callbacks); /* channel = 145 */ while(1) { PROCESS_YIELD(); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udtn_demo_process, ev, data) { static struct registration_api reg; struct mmem * outgoing_bundle_memory = NULL; uint8_t payload[255]; uint32_t tmp; PROCESS_BEGIN(); /* Wait for the agent to be initialized */ PROCESS_PAUSE(); /* Register our endpoint to receive bundles */ reg.status = APP_ACTIVE; reg.application_process = PROCESS_CURRENT(); reg.app_id = 25; process_post(&agent_process, dtn_application_registration_event,®); /* Allocate memory for the outgoing bundle */ outgoing_bundle_memory = bundle_create_bundle(); if( outgoing_bundle_memory == NULL ) { printf("No memory to send bundle\n"); return -1; } /* Get the bundle flags */ bundle_get_attr(outgoing_bundle_memory, FLAGS, &tmp); /* Set the bundle flags to singleton */ tmp = BUNDLE_FLAG_SINGLETON; bundle_set_attr(outgoing_bundle_memory, FLAGS, &tmp); /* Add the payload block */ bundle_add_block(outgoing_bundle_memory, BUNDLE_BLOCK_TYPE_PAYLOAD, BUNDLE_BLOCK_FLAG_NULL, payload, 255); /* To send the bundle, we send an event to the agent */ process_post(&agent_process, dtn_send_bundle_event, (void *) outgoing_bundle_memory); TEST_PASS(); PROCESS_END(); }
PROCESS_THREAD(test_process, ev, data) { static uint32_t time_start = 0; static uint32_t time_stop = 0; static uint32_t errors = 0; static uint32_t collisions = 0; uint32_t i = 0; uint32_t test_data[10] = {251284450, 371537862, 425973621, 81975339, 170405567, 225666122, 421777121, 118094495, 410814580, 414999832}; PROCESS_BEGIN(); PROCESS_PAUSE(); printf("Init done, starting test using redudancy implementation %s\n", REDUNDANCE.name); // Initialize the profiling profiling_init(); profiling_start(); // Measure the current time time_start = test_precise_timestamp(); // ----------------------------------- // Check if no bundles are stored printf("Making sure list is empty\n"); for(i=0; i<0xFFFFF; i++) { if( REDUNDANCE.check(i) ) { errors ++; printf("ERROR: %lu reported to be set but should be empty\n", i); } // Keep the watchdog happy if( i % 10 == 0 ) { watchdog_periodic(); } if( i % 10000 == 0 ) { printf("\t%lu...\n", i); } } // ----------------------------------- // Store 10 bundles printf("Storing 10 bundles...\n"); for(i=0; i<10; i++) { REDUNDANCE.set(test_data[i]); // Keep the watchdog happy if( i % 5 == 0 ) { watchdog_periodic(); } } // Keep the watchdog happy watchdog_periodic(); // ----------------------------------- // Retrieve the 10 bundles printf("Reading 10 bundles back...\n"); for(i=0; i<10; i++) { if( !REDUNDANCE.check(test_data[i]) ) { printf("ERROR: %lu should be set but is not\n", i); errors++; } else { printf("\t%lu is fine\n", test_data[i]); } } // Keep the watchdog happy watchdog_periodic(); // ----------------------------------- // Check how many bundle ID are actually reported as set printf("Counting collisions...\n"); for(i=0; i<0xFFFFF; i++) { if( REDUNDANCE.check(i) ) { printf("\tcollision at %lu\n", i); collisions ++; } // Keep the watchdog happy if( i % 10 == 0 ) { watchdog_periodic(); } if( i % 10000 == 0 ) { printf("\t%lu...\n", i); } } printf("We have %lu collisions\n", collisions); // Keep the watchdog happy watchdog_periodic(); // ----------------------------------- // Now set 1000 bundle IDs and check the last 10 of them printf("Setting 1000 bundle IDs...\n"); for(i=0; i<1000; i++) { REDUNDANCE.set(i); // Keep the watchdog happy if( i % 5 == 0 ) { watchdog_periodic(); } } // Keep the watchdog happy watchdog_periodic(); printf("Verifying IDs...\n"); for(i=990; i<1000; i++) { if( !REDUNDANCE.check(i) ) { printf("ERROR: %lu should be set but is not\n", i); errors++; } // Keep the watchdog happy if( i % 5 == 0 ) { watchdog_periodic(); } } printf("Done\n"); // Measure the current time time_stop = test_precise_timestamp(); watchdog_stop(); profiling_report("redundancy", 0); TEST_REPORT("No of errors", errors, 1, "errors"); TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s"); TEST_REPORT("No of collisions", collisions, 1, "collisions"); if( errors > 0 ) { TEST_FAIL("More than 1 error occurred"); } else { TEST_PASS(); } PROCESS_END(); }
void test_ThisTestAlwaysPasses(void) { TEST_PASS(); }
PROCESS_THREAD(test_process, ev, data) { static int n; static uint32_t i; static int errors = 0; static struct etimer timer; static uint32_t time_start, time_stop; PROCESS_BEGIN(); /* Initialize the flash before the storage comes along */ PRINTF("Intializing Flash...\n"); BUNDLE_STORAGE.format(); PROCESS_PAUSE(); profiling_init(); profiling_start(); // Wait again etimer_set(&timer, CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&timer)); printf("Init done, starting test using %s storage\n", BUNDLE_STORAGE.name); profiling_init(); profiling_start(); // Measure the current time time_start = test_precise_timestamp(); PRINTF("Create and Verify bundles in sequence\n"); for(i=0; i<TEST_BUNDLES; i++) { PROCESS_PAUSE(); if( my_create_bundle(i, &bundle_numbers[i], 3600) ) { PRINTF("\tBundle %lu created successfully \n", i); } else { PRINTF("\tBundle %lu could not be created \n", i); errors ++; continue; } if( my_verify_bundle(bundle_numbers[i], i) ) { PRINTF("\tBundle %lu read back successfully \n", i); } else { PRINTF("\tBundle %lu could not be read back and verified \n", i); errors ++; } } printf("Reinitialize storage\n"); /* Reinitialize the storage and see, if the bundles persist */ BUNDLE_STORAGE.init(); PRINTF("Verify and Delete bundles in sequence\n"); for(i=0; i<TEST_BUNDLES; i++) { if( my_verify_bundle(bundle_numbers[i], i) ) { PRINTF("\tBundle %lu read back successfully \n", i); } else { PRINTF("\tBundle %lu could not be read back and verified \n", i); errors ++; } n = BUNDLE_STORAGE.del_bundle(bundle_numbers[i], REASON_DELIVERED); if( n ) { PRINTF("\tBundle %lu deleted successfully\n", i); } else { PRINTF("\tBundle %lu could not be deleted\n", i); errors++; } } time_stop = test_precise_timestamp(); watchdog_stop(); profiling_report("persistent-storage", 0); TEST_REPORT("No of errors", errors, 1, "errors"); TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s"); if( errors > 0 ) { TEST_FAIL("More than 1 error occured"); } else { TEST_PASS(); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(coffee_test_process, ev, data) { int fd_write, n, i; static int cnt = 0; uint8_t buffer[FILE_SIZE]; clock_time_t now; unsigned short now_fine; static uint32_t time_start, time_stop; printf("###########################################################\n"); PROCESS_BEGIN(); printf("process running\n"); // wait for 5 sec etimer_set(&et, CLOCK_SECOND * 5); PROCESS_YIELD_UNTIL(etimer_expired(&et)); #if (COFFEE_DEVICE == 6) int initialized = 0, i; SDCARD_POWER_ON(); //--- Detecting devices and partitions TEST_EQUALS(diskio_detect_devices(), DISKIO_SUCCESS); info = diskio_devices(); for (i = 0; i < DISKIO_MAX_DEVICES; i++) { if ((info + i)->type == (DISKIO_DEVICE_TYPE_SD_CARD | DISKIO_DEVICE_TYPE_PARTITION)) { info += i; initialized = 1; break; } } TEST_EQUALS(initialized, 1); diskio_set_default_device(info); #endif printf("fomartting...\n"); TEST_EQUALS(cfs_coffee_format(), 0); //printf("test starting\n"); do { now_fine = clock_time(); now = clock_seconds(); } while (now_fine != clock_time()); time_start = ((unsigned long)now)*CLOCK_SECOND + now_fine%CLOCK_SECOND; while(1) { // Shortest possible pause PROCESS_PAUSE(); // Determine the filename char b_file[8]; sprintf(b_file,"%u.b", cnt); // Set the file size printf("Reserving '%s'...\n", b_file); TEST_EQUALS(cfs_coffee_reserve(b_file, FILE_SIZE), 0); // And open it printf("Opening '%s'...\n", b_file); fd_write = cfs_open(b_file, CFS_WRITE); TEST_NEQ(fd_write, -1); // fill buffer for(i=0; i<FILE_SIZE; i++) { buffer[i] = cnt % 0xFF; } // Open was successful, write has to be successful too since the size has been reserved printf("Writing'%s'...\n", b_file); n = cfs_write(fd_write, buffer, FILE_SIZE); cfs_close(fd_write); TEST_EQUALS(n, FILE_SIZE); printf("%s written\n", b_file); if( cnt >= FILES_IN_STORAGE ) { int fd_read; // Figure out the filename char r_file[8]; sprintf(r_file,"%u.b", cnt - FILES_IN_STORAGE); // Open the bundle file printf("Reopening '%s'...\n", r_file); fd_read = cfs_open(r_file, CFS_READ); if(fd_read == -1) { // Could not open file printf("############# STORAGE: could not open file %s\n", r_file); fail(); } memset(buffer, 0, FILE_SIZE); // And now read the bundle back from flash printf("Reading '%s'...\n", b_file); if (cfs_read(fd_read, buffer, FILE_SIZE) == -1){ printf("############# STORAGE: cfs_read error\n"); cfs_close(fd_read); fail(); } cfs_close(fd_read); for(i=0; i<FILE_SIZE; i++) { if( buffer[i] != (cnt - FILES_IN_STORAGE) % 0xFF ) { printf("############# STORAGE: verify error\n"); fail(); } } if( cfs_remove(r_file) == -1 ) { printf("############# STORAGE: unable to remove %s\n", r_file); fail(); } printf("%s deleted\n", r_file); } cnt ++; if( cnt >= 10 ) { do { now_fine = clock_time(); now = clock_seconds(); } while (now_fine != clock_time()); time_stop = ((unsigned long)now)*CLOCK_SECOND + now_fine%CLOCK_SECOND; TEST_REPORT("data written", FILE_SIZE*cnt*CLOCK_SECOND, time_stop-time_start, "bytes/s"); TEST_PASS(); watchdog_stop(); while(1); } } PROCESS_END(); }
PROCESS_THREAD(test_process, ev, data) { static int n; static int i; static int errors = 0; static struct etimer timer; static uint32_t time_start, time_stop; uint8_t buffer[128]; int bundle_length; struct mmem * bundle_original = NULL; struct mmem * bundle_restored = NULL; struct mmem * bundle_spare = NULL; uint32_t bundle_number; uint32_t bundle_number_spare; PROCESS_BEGIN(); PROCESS_PAUSE(); profiling_init(); profiling_start(); // Wait again etimer_set(&timer, CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&timer)); /* Profile initialization separately */ profiling_stop(); watchdog_stop(); profiling_report("init", 0); watchdog_start(); printf("Init done, starting test using %s storage\n", BUNDLE_STORAGE.name); profiling_init(); profiling_start(); // Measure the current time time_start = test_precise_timestamp(); for(i=0; i<=1; i++) { struct mmem bla; if( i > 0 ) { mmem_alloc(&bla, 1); } printf("Serializing and deserializing bundle...\n"); if( my_create_bundle(0, &bundle_number, 3600) ) { printf("\tBundle created successfully \n"); } else { printf("\tBundle could not be created \n"); errors ++; } printf("Serializing and deserializing bundle...\n"); if( my_create_bundle(1, &bundle_number_spare, 3600) ) { printf("\tSpare Bundle created successfully \n"); } else { printf("\tSpare Bundle could not be created \n"); errors ++; } bundle_original = BUNDLE_STORAGE.read_bundle(bundle_number); if( bundle_original == NULL ) { printf("VERIFY: MMEM ptr is invalid\n"); errors ++; } bundle_spare = BUNDLE_STORAGE.read_bundle(bundle_number_spare); if( bundle_spare == NULL ) { printf("VERIFY: MMEM ptr is invalid\n"); errors ++; } // Fake timing information in the bundle to make verify successful struct bundle_t * bundle_original_bundle = (struct bundle_t *) MMEM_PTR(bundle_original); bundle_original_bundle->aeb_value_ms = 54; bundle_original_bundle->rec_time = clock_time(); // Serialize the bundle memset(buffer, 0, 128); bundle_length = bundle_encode_bundle(bundle_original, buffer, 128); if( bundle_length < 0 ) { printf("SERIALIZE: fail\n"); errors ++; } n = my_static_compare(buffer, bundle_length); if( n > 0 ) { printf("COMPARE: fail\n"); errors += n; } // Deserialize it bundle_restored = bundle_recover_bundle(buffer, bundle_length); if( bundle_restored == NULL ) { printf("DESERIALIZE: unable to recover\n"); errors ++; } n = my_compare_bundles(bundle_original, bundle_restored); if( n == 0 ) { printf("\tBundle serialized and deserialized successfully\n"); } else { printf("COMPARE: differences\n"); errors ++; } // Dellocate memory bundle_decrement(bundle_restored); bundle_restored = NULL; bundle_decrement(bundle_original); bundle_original = NULL; bundle_decrement(bundle_spare); bundle_spare = NULL; memset(buffer, 0, 128); // Delete bundle from storage n = BUNDLE_STORAGE.del_bundle(bundle_number, REASON_DELIVERED); if( n ) { printf("\tBundle deleted successfully\n"); } else { printf("\tBundle could not be deleted\n"); errors++; } printf("Comparing static bundle...\n"); if( my_create_bundle(0, &bundle_number, 3600) ) { printf("\tReference Bundle created successfully \n"); } else { printf("\ttReference Bundle could not be created \n"); errors ++; } bundle_original = BUNDLE_STORAGE.read_bundle(bundle_number); if( bundle_original == NULL ) { printf("VERIFY: MMEM ptr is invalid\n"); errors ++; } // Deserialize it bundle_restored = bundle_recover_bundle(static_compare_bundle, sizeof(static_compare_bundle)); if( bundle_restored == NULL ) { printf("DESERIALIZE: unable to recover static bundle\n"); errors ++; } // Deserialize it one more time bundle_spare = bundle_recover_bundle(static_compare_bundle, sizeof(static_compare_bundle)); if( bundle_spare == NULL ) { printf("DESERIALIZE: unable to recover static bundle\n"); errors ++; } n = my_compare_bundles(bundle_original, bundle_restored); if( n == 0 ) { printf("\tStatic Bundle verified successfully\n"); } else { printf("COMPARE: differences\n"); errors ++; } n = my_compare_bundles(bundle_original, bundle_spare); if( n == 0 ) { printf("\tStatic Bundle verified successfully\n"); } else { printf("COMPARE: differences\n"); errors ++; } // Dellocate memory bundle_decrement(bundle_restored); bundle_restored = NULL; bundle_decrement(bundle_original); bundle_original = NULL; bundle_decrement(bundle_spare); bundle_spare = NULL; } time_stop = test_precise_timestamp(); watchdog_stop(); profiling_report("serializer", 0); TEST_REPORT("No of errors", errors, 1, "errors"); TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s"); if( errors > 0 ) { TEST_FAIL("More than 0 errors occured"); } else { TEST_PASS(); } PROCESS_END(); }