static void test_raw_expected(const char * uriStr, const char * testBuf, size_t testLen, const char * expectBuf, size_t expectLen, lwm2m_media_type_t format, const char * id) { lwm2m_data_t * tlvP; lwm2m_uri_t uri; int size; if (uriStr != NULL) { lwm2m_stringToUri(uriStr, strlen(uriStr), &uri); } size = lwm2m_data_parse((uriStr != NULL) ? &uri : NULL, (uint8_t *)testBuf, testLen, format, &tlvP); CU_ASSERT_TRUE_FATAL(size>0); // Serialize to the same format and compare to the input buffer test_data_and_compare(uriStr, format, tlvP, size, id, (uint8_t*)expectBuf, expectLen); // Serialize to the other format respectivly. if (format == LWM2M_CONTENT_TLV) test_data(uriStr, LWM2M_CONTENT_JSON, tlvP, size, id); else if (format == LWM2M_CONTENT_JSON) test_data(uriStr, LWM2M_CONTENT_TLV, tlvP, size, id); }
char *test_insert_then_swim() { priority_queue_p queue = priority_queue_create(sizeof(int), compare_intp); priority_queue_insert(queue, test_data(10)); priority_queue_insert(queue, test_data(20)); mu_assert(*(int*)vector_get(queue->vector, 0) == 10, "should have set first item"); priority_queue_free(queue); return NULL; }
TEST(fatal_debug, fieldM) { auto pod = test_data(); pod.fieldM.clear(); TEST_IMPL(pod, "<root>.fieldM"); pod.fieldM.insert(11); pod.fieldM.insert(12); pod.fieldM.insert(13); pod.fieldM.insert(14); TEST_IMPL(pod, "<root>.fieldM.0"); pod.fieldM = test_data().fieldM; TEST_IMPL(pod); }
char *test_set() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(1)); int set = vector_set(vector, 0, test_data(2)); mu_assert(*(int*)vector_get(vector, 0) == 2, "expected 2"); mu_assert(set, "expected to have set"); vector_free(vector); return NULL; }
char *test_copy_shallow() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(0)); vector_add(vector, test_data(1)); vector_p copy = vector_copy_shallow(vector); mu_assert(vector->length == copy->length, "expected same length for clone"); mu_assert(*(int*)vector_get(copy, 1) == 1, "expected data to be copied"); vector_free(copy); vector_free(vector); return NULL; }
char *test_insert_at_end() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(0)); vector_add(vector, test_data(1)); int did_insert = vector_insert(vector, 2, test_data(2)); mu_assert(vector->length == 3, "should have a length of 3"); mu_assert(did_insert, "should have inserted"); mu_assert(*(int*)vector_get(vector, 2) == 2, "should have added item at end"); vector_free(vector); return NULL; }
char *test_insert_at_beginning() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(1)); int did_insert = vector_insert(vector, 0, test_data(0)); mu_assert(vector->length == 2, "should have a length of 2"); mu_assert(did_insert, "should have inserted"); mu_assert(*(int*)vector_get(vector, 0) == 0, "should have added item at start"); mu_assert(*(int*)vector_get(vector, 1) == 1, "should have moved other items"); vector_free(vector); return NULL; }
TEST(fatal_debug, fieldC) { auto pod = test_data(); pod.fieldC = enum1::field2; TEST_IMPL(pod, "<root>.fieldC"); pod.fieldC = enum1::field0; TEST_IMPL(pod); }
char *test_swap() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(0)); vector_add(vector, test_data(1)); int swapped = vector_swap(vector, 0, 1); mu_assert(swapped, "expected to have swapped"); mu_assert(*(int*)vector_get(vector, 0) == 1, "expected 1"); mu_assert(*(int*)vector_get(vector, 1) == 0, "expected 0"); vector_free(vector); return NULL; }
TEST(fatal_debug, fieldG_field0) { auto pod = test_data(); pod.fieldG.field0 = 12; TEST_IMPL(pod, "<root>.fieldG.field0"); pod.fieldG.field0 = 98; TEST_IMPL(pod); }
TEST(fatal_debug, fieldG_field1) { auto pod = test_data(); pod.fieldG.field1 = "should mismatch"; TEST_IMPL(pod, "<root>.fieldG.field1"); pod.fieldG.field1 = "hello, world"; TEST_IMPL(pod); }
void test_header (void) { const gchar name[] = "X-HEADER-NAME"; const gchar value[] = "MilterServerContext test"; const gchar *packet; gsize packet_size; test_data(); channel_free(); reply_continue(); cut_assert_true(milter_server_context_header(context, name, value)); pump_all_events(); milter_test_assert_state(HEADER); milter_test_assert_status(NOT_CHANGE); milter_command_encoder_encode_header(encoder, &packet, &packet_size, name, value); milter_test_assert_packet(channel, packet, packet_size); cut_assert_equal_uint(0, n_message_processed); }
TEST(fatal_debug, fieldG_field2) { auto pod = test_data(); pod.fieldG.field2 = enum1::field1; TEST_IMPL(pod, "<root>.fieldG.field2"); pod.fieldG.field2 = enum1::field2; TEST_IMPL(pod); }
char *test_remove() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(0)); vector_add(vector, test_data(1)); vector_add(vector, test_data(2)); vector_remove(vector, 1); mu_assert(vector->length == 2, "should have a length of 2"); mu_assert(*(int*)vector_get(vector, 1) == 2, "should have removed item"); vector_free(vector); return NULL; }
TEST(fatal_debug, fieldB) { auto pod = test_data(); pod.fieldB = "should mismatch"; TEST_IMPL(pod, "<root>.fieldB"); pod.fieldB = "this is a test"; TEST_IMPL(pod); }
/** * @brief Parses the testBuf to an array of lwm2m_data_t objects and serializes the result * to TLV and JSON and if applicable compares it to the original testBuf. * @param testBuf The input buffer. * @param testLen The length of the input buffer. * @param format The format of the testBuf. Maybe LWM2M_CONTENT_TLV or LWM2M_CONTENT_JSON at the moment. * @param id The test object id for debug out. */ static void test_raw(const char * uriStr, const char * testBuf, size_t testLen, lwm2m_media_type_t format, const char * id) { lwm2m_data_t * tlvP; lwm2m_uri_t uri; int size; if (uriStr != NULL) { lwm2m_stringToUri(uriStr, strlen(uriStr), &uri); } size = lwm2m_data_parse((uriStr != NULL) ? &uri : NULL, (uint8_t *)testBuf, testLen, format, &tlvP); CU_ASSERT_TRUE_FATAL(size>0); // Serialize to the same format and compare to the input buffer test_data_and_compare(uriStr, format, tlvP, size, id, (uint8_t*)testBuf, testLen); // Serialize to the TLV format // the reverse is not possible as TLV format loses the data type information if (format == LWM2M_CONTENT_JSON) { test_data(uriStr, LWM2M_CONTENT_TLV, tlvP, size, id); } }
TEST(fatal_debug, fieldA) { auto pod = test_data(); pod.fieldA = 90; TEST_IMPL(pod, "<root>.fieldA"); pod.fieldA = 141; TEST_IMPL(pod); }
TEST(fatal_debug, fieldH) { auto pod = test_data(); pod.fieldH.set_ui_2(3); TEST_IMPL(pod, "<root>.fieldH"); pod.fieldH.__clear(); TEST_IMPL(pod); }
int main(int argc, char **argv) { test_asp_up(); test_data(); printf("All tests passed.\n"); return 0; }
void test_init(const int distribution, const int nparts, const int accuracy, const int s, const double beta, double **ploc, double **pcharge, double **pot, double **field, double **dxx, double **dyy, double **dzz, double **dxy, double **dxz, double **dyz) { // The function completes two tasks: (1) Allocate memory to hold particle locations // and the charges carried by them, and to hold the computed potential and field // result; (2) Generate the input data as specified by the distribution variable. char* datatype[] = {"", " CUBE", "SPHERE", "OCTANT"}; // Allocate memory to hold particle information and output results. (*ploc) = (double *)calloc(3*nparts, sizeof(double)); (*pcharge) = (double *)calloc(3*nparts, sizeof(double)); (*pot) = (double *)calloc(nparts, sizeof(double)); (*field) = (double *)calloc(3*nparts, sizeof(double)); (*dxx) = (double *)calloc(nparts, sizeof(double)); (*dyy) = (double *)calloc(nparts, sizeof(double)); (*dzz) = (double *)calloc(nparts, sizeof(double)); (*dxy) = (double *)calloc(nparts, sizeof(double)); (*dxz) = (double *)calloc(nparts, sizeof(double)); (*dyz) = (double *)calloc(nparts, sizeof(double)); int allocFailure = (*ploc==0) || (*pcharge==0) || (*pot==0) || (*field==0) || (*dxx == 0) || (*dyy == 0) ||(*dzz == 0) ||(*dxy == 0) || (*dxz == 0) || (*dyz == 0); if ( allocFailure ) { printf("Error in %s, line %d: unable to allocate memory\n", __FILE__, __LINE__); exit(-1); } // Generate input data set for the demo test_data(nparts, distribution, *ploc, *pcharge); // Print summary of the demo if ( beta > 0 ) { printf("\n\tDEMO FMM-YUKAWA RUN\n" "\n\tSETUP\n\n" "======================================================\n" "# OF PARTICLE | %20d\n" "DISTRIBUTION | \t\t %s\n" "S | %20d\n" "ACCURACY | %20d\n" "======================================================\n", nparts, datatype[distribution], s, accuracy); } else if ( beta == 0 ) { printf("\n\tDEMO FMM-LAPLACE RUN\n" "\n\tSETUP\n\n" "======================================================\n" "# OF PARTICLE | %20d\n" "DISTRIBUTION | \t\t %s\n" "S | %20d\n" "ACCURACY | %20d\n" "======================================================\n", nparts, datatype[distribution], s, accuracy); } return; }
char *test_add_elements() { vector_p vector = vector_create(sizeof(int)); size_t i0 = vector_add(vector, test_data(0)); size_t i1 = vector_add(vector, test_data(1)); size_t i2 = vector_add(vector, test_data(2)); mu_assert(*(int*)vector_get(vector, 0) == 0, "expected 0"); mu_assert(*(int*)vector_get(vector, 1) == 1, "expected 1"); mu_assert(*(int*)vector_get(vector, 2) == 2, "expected 2"); mu_assert(i0 == 0, "should have index 0"); mu_assert(i1 == 1, "should have index 1"); mu_assert(i2 == 2, "should have index 2"); vector_free(vector); return NULL; }
int main(int argc, const char** argv) { SVM vm = SVM_INIT; test_data(&vm); test_arithmetic(&vm); test_logic_tests(&vm); test_control_flow(&vm); return 0; }
TEST(fatal_debug, fieldG_field5) { auto pod = test_data(); pod.fieldG.field5.set_ui_2(5); TEST_IMPL(pod, "<root>.fieldG.field5"); pod.fieldG.field5.__clear(); TEST_IMPL(pod, "<root>.fieldG.field5"); pod.fieldG.field5.set_ue_2(enum1::field0); TEST_IMPL(pod, "<root>.fieldG.field5.ue_2"); pod.fieldG.field5.set_ue_2(enum1::field1); TEST_IMPL(pod); }
char *test_get() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(1)); int data = *((int*)vector_get(vector, 0)); mu_assert(data == 1, "expected same value"); vector_free(vector); return NULL; }
char *test_set_out_of_range() { vector_p vector = vector_create(sizeof(int)); int set = vector_set(vector, 3500, test_data(2)); mu_assert(!set, "expected to not have set"); vector_free(vector); return NULL; }
TEST(fatal_debug, fieldQ) { auto pod = test_data(); pod.fieldQ.clear(); TEST_IMPL(pod, "<root>.fieldQ"); structA a1; a1.a = 1; a1.b = "1"; structA a2; a2.a = 2; a2.b = "2"; structA a3; a3.a = 3; a3.b = "3"; pod.fieldQ["A1"] = a1; pod.fieldQ["A2"] = a2; pod.fieldQ["A3"] = a3; TEST_IMPL(pod, "<root>.fieldQ.0"); pod.fieldQ = test_data().fieldQ; TEST_IMPL(pod); }
char *test_add() { vector_p vector = vector_create(sizeof(int)); size_t index = vector_add(vector, test_data(1)); mu_assert(index == 0, "should have added at index 0"); mu_assert(vector->length == 1, "expected length 1"); vector_free(vector); return NULL; }
int main() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(4)); vector_add(vector, test_data(1)); vector_add(vector, test_data(2)); vector_add(vector, test_data(3)); qsort(vector->data, vector->length, sizeof(void*), qscompare); for(size_t i = 0 ; i < vector->length ; i++) { int k = *(int*) vector_get(vector, i); printf("%d\n", k); } vector_free(vector); return 0; }
TEST(fatal_debug, fieldE) { auto pod = test_data(); pod.fieldE.set_ui(5); TEST_IMPL(pod, "<root>.fieldE"); pod.fieldE.__clear(); TEST_IMPL(pod, "<root>.fieldE"); pod.fieldE.set_ud(4); TEST_IMPL(pod, "<root>.fieldE.ud"); pod.fieldE.set_ud(5.6); TEST_IMPL(pod); }
void thread_channel_recv(void *arg) { struct timeval tm_start,tm_end; fvl_read_rvl_t rlen; uint8_t i=0; int rvl=0; uint64_t total_count=0; gettimeofday(&tm_start,NULL); int fd=0; int *j=(int *)arg; printf("j:%d\n",*j); int cpu=*j+11; cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(cpu,&cpuset); rvl = pthread_setaffinity_np(pthread_self(),sizeof(cpu_set_t),&cpuset); if(rvl){ printf("(%d)fail:pthread_setaffinity_np()\n",cpu); return; } fd=fvl_srio_channel_open(channame[*j]); printf("##################fd:%d*****************\n",fd); if(fd<0) { printf("error!\n"); return; } gettimeofday(&tm_start,NULL); while(1) { rlen.len=0x100000; rvl=fvl_srio_read(fd,&rlen); if(rlen.len!=0) { test_data(i,rlen.buf_virt,10485,0); i++; // printf("##########:%d\n",i); gettimeofday(&tm_end,NULL); total_count++; double diff=(tm_end.tv_sec-tm_start.tv_sec)+(tm_end.tv_usec-tm_start.tv_usec)/1000000.0; if(diff>5) { double da_lu=total_count/diff; printf("fd: %d length(byte): %-15u time(s): %-15f avg MB/s: %-15f total_count:%lld \n",fd,rlen.len,diff,da_lu,total_count); fflush(stdout); total_count=0; gettimeofday(&tm_start,NULL); } fvl_srio_read_feedback(fd,rlen.num); } } }