int main(int argc, char **argv) { BOOL aisFinish = FALSE,bisFinish = FALSE; Wilddog_T wilddog_a = 0; Wilddog_T wilddog_b = 0; if( argc != 3 ) { printf("input : \t ./test_mutiple_observer url1/path1 url2/path2 \n"); return -1; } wilddog_a = wilddog_initWithUrl((Wilddog_Str_T*)argv[1]); wilddog_b = wilddog_initWithUrl((Wilddog_Str_T*)argv[2]); wilddog_addObserver(wilddog_a, WD_ET_VALUECHANGE,\ addObserver_callback_a, \ (void*)&aisFinish); wilddog_addObserver(wilddog_b, WD_ET_VALUECHANGE,\ addObserver_callback_b, \ (void*)&bisFinish); while(1) { wilddog_trySync(); } wilddog_destroy(&wilddog_a); wilddog_destroy(&wilddog_b); return 0; }
void WD_SYSTEM performtest_handle ( u32 delay_tm, const u8 *p_url, u32 tree_num, u8 request_num ) { u8 m = 0; performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl((Wilddog_Str_T*)p_url); if(0 == wilddog) { return; } perform_count = 0; wilddog_debug(); performtest_setSysState(SYS_AUTHRECV); wilddog_debug(); performtest_timeReset(); wilddog_debug(); os_timer_disarm(&test_timer2); os_timer_setfn(&test_timer2, (os_timer_func_t *)perform_sync, NULL); os_timer_arm(&test_timer2, 1000, 0); return; }
STATIC void stab_settest_dataInit(u8 idx) { int i; //char temp_url[strlen(TEST_URL)+20]; char temp_url[256]; memset(temp_url,0,sizeof(temp_url)); for(i=0;i<10;i++) { stab_setdata[i].key[0] = 'K'; stab_setdata[i].data[0] = 'D'; stab_setdata[i].key[1] = 0x30+i; stab_setdata[i].data[1] = 0x30+idx; stab_setdata[i].data[2] = 0x30+i; sprintf((char*)temp_url,"%s/%s",TEST_URL,stab_setdata[i].key); if(stab_setdata[i].client) wilddog_destroy(&(stab_setdata[i].client)); stab_setdata[i].client = wilddog_initWithUrl((Wilddog_Str_T*)temp_url); if(stab_setdata[i].p_node) { wilddog_node_delete(stab_setdata[i].p_node); stab_setdata[i].p_node = NULL; } stab_setdata[i].p_node = wilddog_node_createUString( (Wilddog_Str_T *)stab_setdata[i].key,\ (Wilddog_Str_T *)stab_setdata[i].data); } }
Wilddog_T init_wilddog( char*url) { Wilddog_T _wd; _wd = wilddog_initWithUrl((Wilddog_Str_T *)url); if(0 == _wd) { wilddog_debug("new wilddog failed! %s\n",url); return 0; } return _wd; }
void ramtest_handle( u8 tree_num, u8 request_num) { u8 m = 0; Wilddog_T wilddog = 0; u8 url[64]={0}; ramtest_init(tree_num,request_num); sprintf((char*)url, "coaps://c_test.wilddogio.com/ramtest/tree_%d", tree2len[tree_num]); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { return; } count = 0; for(m=0; m < request_num; m++) { int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL); if(0 == res) count++; else d_ramtest.d_sendfalt++; } ramtest_caculate_requestQueueRam(); while(1) { if(count == 0) { ramtest_printf(&d_ramtest); break; } ramtest_getAveragesize(); wilddog_trySync(); } wilddog_destroy(&wilddog); return;
int stab_oneCrcuRequest(void) { int res = 0; BOOL otherFinish = FALSE,onFinish = FALSE; BOOL *p_finish = &onFinish; Wilddog_T client = 0; STABTEST_CMD_TYPE cmd = STABTEST_CMD_ON; /* mark star time*/ stab_set_runtime(); /*Init a wilddog client*/ client = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL); stab_get_requestRes(stabtest_request(cmd,client,p_finish)); while(1) { if(TRUE == *p_finish) { if(STABTEST_ONREQUEST(cmd)) p_finish = &otherFinish; onFinish = FALSE; otherFinish = FALSE; STABTEST_NEXTREQUEST(cmd); stab_get_requestRes(stabtest_request(cmd,client,p_finish)); if(STABTEST_OFFREQUEST(cmd)) { break; } } stab_trysync(); } /*Destroy the wilddog clent and release the memory*/ res = wilddog_destroy(&client); return res; }
int main(void) { char host1[TESTURL_NUM],host2[TESTURL_NUM],host3[TESTURL_NUM]; Wilddog_T client1= 0,client2 = 0,client3 = 0; memset(host1,0,TESTURL_NUM); memset(host2,0,TESTURL_NUM); memset(host3,0,TESTURL_NUM); printf(" @@mutiple test\n"); printf("APPID : %s \n",TEST_URL); printf("APPID2 : %s \n",TEST_URL2); printf("APPID3 : %s \n",TEST_URL3); test_gethost(host1,TEST_URL); test_gethost(host2,TEST_URL2); test_gethost(host3,TEST_URL3); multipleClient[0].p_host = host1; multipleClient[1].p_host = host2; multipleClient[2].p_host = host3; client1 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL); client2 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL2); client3 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL3); /* set */ printf("test set \n"); multipletest_request(MULTIPLETEST_CMD_SET,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_SET,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_SET,client3,&multipleClient[2]); multiple_trysync(); printf("test get \n"); /*get */ multipletest_request(MULTIPLETEST_CMD_GET,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_GET,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_GET,client3,&multipleClient[2]); multiple_trysync(); printf("test observer \n"); //while(1); /* ON */ multipletest_request(MULTIPLETEST_CMD_ON,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_ON,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_ON,client3,&multipleClient[2]); multiple_trysync(); /*PUSH */ printf("test PUSH \n"); multipletest_request(MULTIPLETEST_CMD_PUSH,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_PUSH,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_PUSH,client3,&multipleClient[2]); multiple_trysync(); /*DELETE */ printf("test delete \n"); multipletest_request(MULTIPLETEST_CMD_DELE,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_DELE,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_DELE,client3,&multipleClient[2]); multiple_trysync(); /* OFF multipletest_request(MULTIPLETEST_CMD_ON,client1,&multipleClient[0]); multipletest_request(MULTIPLETEST_CMD_ON,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_ON,client3,&multipleClient[2]); multiple_trysync(); */ /* result printf */ multiple_testResultPrint(&multipleClient[0]); multiple_testResultPrint(&multipleClient[1]); multiple_testResultPrint(&multipleClient[2]); /* destory*/ wilddog_destroy(&client1); wilddog_destroy(&client2); wilddog_destroy(&client3); if( multiple_testResultReturn(&multipleClient[0]) == -1 || multiple_testResultReturn(&multipleClient[1]) == -1 || multiple_testResultReturn(&multipleClient[2]) == -1 ) return -1; else return 0; }
void WD_SYSTEM performtest_handle ( u32 delay_tm, const u8 *p_url, u32 tree_num, u8 request_num ) { u8 m = 0; Wilddog_T wilddog = 0; performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl((Wilddog_Str_T*)p_url); if(0 == wilddog) { return; } perform_count = 0; performtest_setSysState(SYS_AUTHRECV); performtest_timeReset(); while(1) { wilddog_trySync(); if(SYS_ISIN(SYS_APPLICATIONSENDING)) break; } performtest_timeReset(); for(m=0; m < request_num; m++) { performtest_timeReset(); /*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/ int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL); performtest_getSendTime(); /*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/ if(0 == res) perform_count++; else g_performtest.d_send_fault++; /*printf("send =%d;res =%d \n",perform_count,res);*/ } performtest_timeReset(); performtest_setSysState(SYS_APPLICATIONRECV); while(1) { if(perform_count == 0) { //printf("break\n"); performtest_printf(&g_performtest); break; } #ifdef WILDDOG_PORT_TYPE_WICED wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay); #else #if defined WILDDOG_PORT_TYPE_ESP os_delay_us(1000 * g_performtest.d_tm_trysync_delay); #else usleep(g_performtest.d_tm_trysync_delay); #endif #endif wilddog_increaseTime(g_performtest.d_tm_trysync_delay); wilddog_trySync(); } wilddog_destroy(&wilddog); return; }
STATIC int test_buildtreeFunc(void) { int m = 0; u8 url[strlen(TEST_URL)+20]; Wilddog_Node_T *p_head = NULL; //Wilddog_Node_T *p1 = NULL, *p2 = NULL, *p3 = NULL; Wilddog_Node_T *L1[2]; Wilddog_Node_T *L2[4]; Wilddog_Node_T *L3[8]; Wilddog_Node_T *L4[16]; Wilddog_Node_T *L5[32]; Wilddog_Node_T *L6[64]; Wilddog_Node_T *L7[128]; memset(key,0,20); p_head = wilddog_node_createObject(NULL); for(m = 0; m < 2; m++) { snprintf((char*)key, 20 , "%s%d", "L1",m); L1[m] = wilddog_node_createUString( key,(u8*)"L1L"); } for(m = 0; m < 4; m++) { snprintf((char*)key, 20 , "%s%d", "L2",m); L2[m] = wilddog_node_createUString( key,(u8*)"L2L"); } for(m = 0; m < 8; m++) { snprintf((char*)key, 20 , "%s%d", "L3",m); L3[m] = wilddog_node_createUString( key,(u8*)"L3L"); } for(m = 0; m < 16; m++) { snprintf((char*)key, 20 , "%s%d", "L4",m%10); L4[m] = wilddog_node_createUString( key,(u8*)"L4L"); } for(m = 0; m < 32; m++) { snprintf((char*)key, 20 , "%s%d", "L5",m%10); L5[m] = wilddog_node_createUString( key,(u8*)"L5L"); } for(m = 0; m < 64; m++) { snprintf((char*)key, 20 , "%s%d", "L6",m%10); L6[m] = wilddog_node_createUString( key,(u8*)"L6L"); } for(m = 0; m < 128; m++) { snprintf((char*)key, 20 , "%s%d", "L7",m%10); L7[m] = wilddog_node_createUString( key,(u8*)"L7L"); } for(m = 0; m < 2; m++) { wilddog_node_addChild(p_head, L1[m]); } for(m=0; m < 4; m++) { wilddog_node_addChild(L1[m/2], L2[m]); } for(m=0; m < 8; m++) { wilddog_node_addChild(L2[m/2], L3[m]); } for(m=0; m < 16; m++) { wilddog_node_addChild(L3[m/2], L4[m]); } for(m=0; m < 32; m++) { wilddog_node_addChild(L4[m/2], L5[m]); } for(m=0; m < 64; m++) { wilddog_node_addChild(L5[m/2], L6[m]); } for(m=0; m < 128; m++) { wilddog_node_addChild(L6[m/2], L7[m]); } /*3*/ isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_127); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L5[0],test_onSetFunc,(void*)TEST_TREE_T_127); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*4*/ if(TEST_TREE_ITEMS < 2) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_256); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L4[0],test_onSetFunc,(void*)TEST_TREE_T_256); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*5*/ if(TEST_TREE_ITEMS < 3) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_576); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L3[0],test_onSetFunc,(void*)TEST_TREE_T_576); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*6*/ if(TEST_TREE_ITEMS < 4) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_810); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L2[0],test_onSetFunc,(void*)TEST_TREE_T_810); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*7*/ if(TEST_TREE_ITEMS < 5) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_1044); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L1[0],test_onSetFunc,(void*)TEST_TREE_T_1044); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*8*/ if(TEST_TREE_ITEMS < 6) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_1280); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); return -1; } wilddog_setValue(wilddog,p_head,test_onSetFunc,(void*)TEST_TREE_T_1280); wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); if(l_res < 0) printf("build tree error !!\n"); else printf("\n\ttest_buildtree finished\n"); return l_res; }
int main(int argc, char **argv) { char url[1024]; char value[1024]; char keys[256]; char host[512]; char authData[512]; BOOL authFlag = FALSE; memset(url,0,sizeof(url)); memset(value,0,sizeof(value)); memset(keys,0,sizeof(keys)); memset(host,0,sizeof(host)); memset(authData,0,sizeof(authData)); int type = 0; int opt,i,res = 0,cnt=0,cntmax=0; int option_index = 0; BOOL isFinish = FALSE,authFinish; Wilddog_T wilddog = 0; Wilddog_Node_T * p_node = NULL,*p_head = NULL; static struct option long_options[] = { {"auth", required_argument, 0, 0 }, {"value", required_argument, 0, 0 }, {"key", required_argument, 0, 0 }, {0, 0, 0, 0 } }; while((opt=getopt_long(argc,argv,"hl:",long_options,&option_index)) != -1) { switch (opt) { case 0: //printf("option %s", long_options[option_index].name); if (optarg) { if(strcmp(long_options[option_index].name,"key")==0) memcpy(keys, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"value")==0) memcpy(value, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"auth")==0) { authFlag = TRUE; memcpy(authData, optarg,strlen(optarg)); } } break; case 'h': fprintf(stderr, \ "Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; case 'l': strcpy(url, (const char*)optarg); getHostFromAppid(host,url); sprintf(&host[strlen(host)],".wilddogio.com"); break; default: /* '?' */ fprintf(stderr, \ "Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; } } for (i = 0; optind < argc; i++, optind++) { if(i == 0) { if(strcmp(argv[optind],"getValue")==0) { type= TEST_CMD_GET; cntmax = 0; } else if(strcmp(argv[optind],"setValue")==0) { type= TEST_CMD_SET; cntmax = 0; } else if(strcmp(argv[optind],"push")==0) { type=TEST_CMD_PUSH; cntmax = 0; } else if(strcmp(argv[optind],"removeValue")==0) { type=TEST_CMD_DELE; cnt =0; } else if(strcmp(argv[optind],"addObserver")==0) { type= TEST_CMD_ON; cntmax = 10; } else if(strcmp(argv[optind],"setAuth")==0) { type= TEST_CMD_SETAUTH; cntmax = 0; } else if(strcmp(argv[optind],"disSetValue")==0) { type= TEST_CMD_ONDISSET; cntmax = 0; } else if(strcmp(argv[optind],"disPush")==0) { type= TEST_CMD_ONDISPUSH; cntmax = 0; } else if(strcmp(argv[optind],"disRemove")==0) { type= TEST_CMD_ONDISREMOVE; cntmax = 0; } else if(strcmp(argv[optind],"cacelDis")==0) { type= TEST_CMD_CANCELDIS; cntmax = 0; } else if(strcmp(argv[optind],"offLine")==0) { type= TEST_CMD_OFFLINE; cntmax = 0; } else if(strcmp(argv[optind],"onLine")==0) { type= TEST_CMD_ONLINE; cntmax = 0; } } } if( !type) { printf("Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; } /*Create an node which type is an object*/ p_head = wilddog_node_createObject(NULL); /*Create an node which type is UTF-8 Sring*/ p_node = wilddog_node_createUString((Wilddog_Str_T *)keys, \ (Wilddog_Str_T *)value); /*Add p_node to p_head, then p_node is the p_head's child node*/ wilddog_node_addChild(p_head, p_node); /*Init a wilddog client*/ wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); if(authFlag == TRUE) res = wilddog_auth((u8*)host,(u8*)authData, \ strlen((const char *)authData), auth_callback,(void*)&authFinish); switch(type) { case TEST_CMD_GET: /*Send the query method*/ res = wilddog_getValue(wilddog, (onQueryFunc)getValue_callback, \ (void*)&isFinish); break; case TEST_CMD_SET: /*Send the set method*/ res = wilddog_setValue(wilddog,p_head,setValue_callback, \ (void*)&isFinish); break; case TEST_CMD_PUSH: /*Send the push method*/ res = wilddog_push(wilddog, p_head, push_callback, \ (void *)&isFinish); break; case TEST_CMD_DELE: /*Send the remove method*/ res = wilddog_removeValue(wilddog, removeValue_callback, \ (void*)&isFinish); break; case TEST_CMD_ON: /*Observe on*/ res = wilddog_addObserver(wilddog, WD_ET_VALUECHANGE,\ addObserver_callback, \ (void*)&isFinish); break; case TEST_CMD_SETAUTH: wilddog_debug("TEST_CMD_SETAUTH token = %s",value); res = wilddog_auth((u8*)host,(u8*)value, \ strlen((const char *)value), auth_callback,(void*)&isFinish); case TEST_CMD_ONDISSET: /*Send the remove method*/ res = wilddog_onDisconnectSetValue(wilddog,p_head,onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_ONDISPUSH: /*Send the remove method*/ res = wilddog_onDisconnectPush(wilddog,p_head,onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_ONDISREMOVE: /*Send the remove method*/ res = wilddog_onDisconnectRemoveValue(wilddog, onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_CANCELDIS: /*Send the remove method*/ res = wilddog_cancelDisconnectOperations(wilddog, onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_OFFLINE: /*Send the remove method*/ res = wilddog_goOffline(); break; case TEST_CMD_ONLINE: /*Send the remove method*/ res = wilddog_goOnline(); break; } /*Delete the node*/ wilddog_node_delete(p_head); while(1) { if(TRUE == isFinish) { if(type == TEST_CMD_ON) wilddog_debug("get new data %d times! after %d times, will " \ "remove Observer.", cnt, cntmax); cnt++; isFinish = FALSE; if(cnt > cntmax)/*force break when received new data.*/ { if(type == TEST_CMD_ON) { wilddog_debug("off the data!"); /*Observe off*/ wilddog_removeObserver(wilddog, WD_ET_VALUECHANGE); } break; } } /* * Handle the event and callback function, it must be called in a * special frequency */ wilddog_trySync(); } /*Destroy the wilddog clent and release the memory*/ wilddog_destroy(&wilddog); return res; }
void performtest_handle( u32 delay_tm,u8 tree_num, u8 request_num) { u8 m = 0; Wilddog_T wilddog = 0; u8 url[64]={0}; sprintf((char*)url, "coaps://c_test.wilddogio.com/performtest/tree_%d", tree2len[tree_num]); performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { return; } perform_count = 0; performtest_setSysState(SYS_AUTHRECV); performtest_star_tm(); while(1) { wilddog_trySync(); if(SYS_ISIN(SYS_APPLICATIONSENDING)) break; } performtest_star_tm(); for(m=0; m < request_num; m++) { performtest_star_tm(); /*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/ int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL); performtest_tm_getSend(); /*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/ if(0 == res) perform_count++; else g_performtest.d_send_fault++; /*printf("send =%d;res =%d \n",perform_count,res);*/ } performtest_star_tm(); performtest_setSysState(SYS_APPLICATIONRECV); while(1) { if(perform_count == 0) { //printf("break\n"); performtest_printf(&g_performtest); break; } #ifdef WILDDOG_PORT_TYPE_WICED wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay); #else usleep(g_performtest.d_tm_trysync_delay); #endif wilddog_increaseTime(g_performtest.d_tm_trysync_delay); wilddog_trySync(); } wilddog_destroy(&wilddog); return; }
int demo(char* url, int* isUnConnected) { BOOL isFinish = FALSE; Wilddog_T wilddog = 0; Wilddog_Node_T * p_node = NULL, *p_head = NULL, *p_node_query = NULL; p_head = wilddog_node_createObject(NULL); /* create a new child to "wilddog" , key is "1", value is "1" */ p_node = wilddog_node_createUString((Wilddog_Str_T*)"led1",(Wilddog_Str_T*)"1"); /*p_node was p_head's child */ wilddog_node_addChild(p_head, p_node); /*creat new a client*/ wilddog = wilddog_initWithUrl((Wilddog_Str_T*)url); if(0 == wilddog) { wilddog_debug("new wilddog error"); return 0; } printf("\n\t seting led1=1 to %s\n",url); /* expect <appId>.wilddogio.com/ has a new node "1" * test_onSetFunc : handle recv data while response * */ wilddog_setValue(wilddog,p_head,test_onSetFunc,(void*)&isFinish); /* dele node */ wilddog_node_delete(p_head); while(1) { if(*isUnConnected) { wilddog_debug("wlan off!"); break; } if(TRUE == isFinish) { wilddog_debug("\tset led1=1 success!"); break; } /*retransmit¡¢ received and handle response * */ wilddog_trySync(); } printf("\n\t send query to %s \n",url); /* send query */ wilddog_getValue(wilddog, test_onQueryFunc, (void*)(&p_node_query)); while(1) { if(p_node_query) { printf("\t get %s data: \n",url); /* printf recv node as json */ wilddog_debug_printnode(p_node_query); /* free p_node_query */ wilddog_node_delete(p_node_query); printf("\n"); break; } wilddog_trySync(); } /* free wilddog*/ wilddog_destroy(&wilddog); return 0; }
int main(int argc, char **argv) { char url[1024]; char cmd[256]; char data[32]; char verbose[32]; char quote[32]; char authvalue[256]; BOOL isFinished = FALSE; Wilddog_T wilddog = 0; int opt; int option_index = 0; WATCH_CTX watch_ctx; char *host = NULL; memset(url,0,sizeof(url)); memset(cmd,0,sizeof(cmd)); memset(data,0,sizeof(data)); memcpy(data, "yes",strlen("yes")); memset(verbose,0,sizeof(verbose)); memcpy(verbose, "no",strlen("no")); memset(quote,0,sizeof(quote)); memcpy(quote, "yes",strlen("yes")); memset(authvalue,0,sizeof(authvalue)); static struct option long_options[] = { {"ignore-origin-data", required_argument, 0, 0 }, {"verbose", required_argument, 0, 0}, {"ignore-leaf-quote", required_argument, 0, 0}, {"version", no_argument, 0, 0}, {"authvalue", required_argument, 0, 0}, {0, 0, 0, 0 } }; while ((opt = getopt_long(argc, argv, "ovsh",long_options, &option_index)) != -1) { switch (opt) { case 0: //printf("option!!! %s\n", long_options[option_index].name); if (optarg) { if(strcmp(long_options[option_index].name,"ignore-origin-data")==0) memcpy(data, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"verbose")==0) memcpy(verbose, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"ignore-leaf-quote")==0) memcpy(quote, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"authvalue")==0) memcpy(authvalue, optarg,strlen(optarg)); } if(strcmp(long_options[option_index].name,"version")==0) { printf("liveshell Version: %s\n", LIVESHELL_VERSION); return 0; } break; case 'o': memcpy(data, "no",strlen("no")); break; case 'v': memcpy(verbose, "yes",strlen("yes")); break; case 's': memcpy(quote, "no",strlen("no")); break; case 'h': fprintf(stderr, "Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; default: /* '?' */ fprintf(stderr, "Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; } } if( argc < 3 ) { printf("Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; } memcpy(cmd, argv[argc-1], strlen(argv[argc-1])); memcpy(url, argv[argc-2], strlen(argv[argc-2])); wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); if(0 == wilddog) { wilddog_debug("new wilddog failed!"); return 0; } if(strlen(authvalue) != 0) { host = getHostFromUrl(url); //printf("host:%s\n", host); //printf("authvalue:%s\n", authvalue); wilddog_auth((u8*)host,(u8*)authvalue,strlen((const char *)authvalue),auth_callback,(void*)&isFinished); } isFinished = FALSE; watch_ctx.cmd = cmd; watch_ctx.data = data; watch_ctx.verbose = verbose; watch_ctx.quote = quote; watch_ctx.isFinished = &isFinished; wilddog_addObserver(wilddog, WD_ET_VALUECHANGE, observer_callback, (void*)&watch_ctx); while(1) { if(TRUE == *(watch_ctx.isFinished)) { //wilddog_debug("get new data %d times!", count++); *(watch_ctx.isFinished) = FALSE; /*do not break*/ //break; } wilddog_trySync(); } wfree(host); wilddog_destroy(&wilddog); return 0; }
int test(char *uid) { char url[1024]; char en_key = 0; BOOL isFinished = FALSE; Wilddog_T wilddog; Wilddog_Handle_T s_handle; Wilddog_Node_T *p_head = NULL, *p_node = NULL/*, *p_snapshot = NULL*/; u8 value1[5] = {246,12,0,0,6}; /*u8 value2[4] = {23,67,98,1};*/ wFloat f = 2.3; Wilddog_Node_T *root; Wilddog_Node_T *L1c1,*L1c2; Wilddog_Node_T *L2c1,*L2c2,*L2c3; Wilddog_Node_T *L3c1,*L3c2,*L3c3,*L3c4,*L3c5; Wilddog_Node_T *L4c1,*L4c2,*L4c3,*L4c4,*L4c5; int count = 0; sprintf(url,"%s%s%s",TEST_URL_HEAD,uid,TEST_URL_END); memset(&s_handle, 0, sizeof(s_handle)); s_handle.isFinished = FALSE; printf("*******************************************\n"); printf("First Step: Build the data tree \n"); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif root = wilddog_node_createNum((Wilddog_Str_T *)"root",9999); L1c1 = wilddog_node_createFalse((Wilddog_Str_T *)"L1c1"); L1c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L1c2"); L2c1 = wilddog_node_createNum((Wilddog_Str_T *)"L2c1",-10000); L2c2 = wilddog_node_createFloat((Wilddog_Str_T *)"L2c2",f); L2c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L2c3"); //true L3c1 = wilddog_node_createBString((Wilddog_Str_T *)"L3c1",value1,sizeof(value1)/sizeof(u8)); //BString L3c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c2"); L3c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c3"); L3c4 = wilddog_node_createNull((Wilddog_Str_T *)"L3c4"); //NULL L3c5 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c5"); L4c1 = wilddog_node_createNum((Wilddog_Str_T *)"L4c1",875);// +Num L4c2 = wilddog_node_createNum((Wilddog_Str_T *)"L4c2",-5693); // -Num L4c3 = wilddog_node_createFloat((Wilddog_Str_T *)"L4c3",f); //float L4c4 = wilddog_node_createFalse((Wilddog_Str_T *)"L4c4"); //false L4c5 = wilddog_node_createUString((Wilddog_Str_T *)"L4c5",(Wilddog_Str_T *)"string"); //UString if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c2,L2c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c2,L4c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } printf("*******************************************\n"); printf("The data is built as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); /* printf("*******************************************\n"); printf("Second Step: Use the Node API to change the data tree\n"); printf("Change the L1c1 node's key from \"L1c1\" to \"L1c1New\" \n"); wilddog_node_setKey(L1c1,(Wilddog_Str_T *)"L1c1New"); printf("Change the L3c1 node's value from Bytestring \"{0xf6,0x0c,0x00,0x00,0x06}\" to Bytestring \"{0x17,0x43,0x62,0x01}\"\n "); wilddog_node_setValue(L3c1,value2,sizeof(value2)/sizeof(u8)); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif printf("*******************************************\n"); printf("The data tree had changed as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /* printf("*******************************************\n"); printf("Clone the data tree from L2c2 node\n"); printf("Print the L2c2 data tree\n"); p_snapshot = wilddog_node_clone(L2c2); wilddog_debug_printnode(p_snapshot); wilddog_node_delete(p_snapshot); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /*************************************************************/ wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); printf("*******************************************\n"); printf("Third step: Remove the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_removeValue(wilddog, test_onDeleteFunc, (void*)&isFinished); while(1) { if(TRUE == isFinished) { wilddog_debug("remove success!"); break; } wilddog_trySync(); } isFinished = FALSE; /*************************************************************/ printf("*******************************************\n"); printf("It has removed all data in %s!\n",uid); printf("Please check the data on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); printf("*******************************************\n"); printf("Fourth step: Set the root node to the %s's data tree\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_setValue(wilddog,root,test_onSetFunc,(void*)&isFinished); wilddog_node_delete(root); while(1) { if(TRUE == isFinished) { wilddog_debug("set success!"); break; } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has set the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ printf("*******************************************\n"); printf("Fifth step: Get the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif s_handle.p_node = NULL; wilddog_getValue(wilddog, test_onQueryFunc, (void*)(&s_handle)); while(1) { if(s_handle.isFinished) { if(s_handle.p_node) { wilddog_debug("print node:"); wilddog_debug_printnode(s_handle.p_node); wilddog_node_delete(s_handle.p_node); s_handle.p_node= NULL; printf("\n"); break; } } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has get the data in %s!\n",uid); printf("Please check the data tree!\n"); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ p_head = wilddog_node_createObject((Wilddog_Str_T *)"3"); p_node = wilddog_node_createNum((Wilddog_Str_T *)"2",1234); wilddog_node_addChild(p_head, p_node); printf("*******************************************\n"); printf("Sixth step: Build a node as \"{\"2\":1234}\"\n"); printf("Push the new node to the %s's data tree's root node\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_push(wilddog, p_head, test_onPushFunc, (void *)&isFinished); wilddog_node_delete(p_head); while(1) { if(isFinished) { wilddog_debug("push success!"); break; } wilddog_trySync(); } printf("*******************************************\n"); printf("It has pushed the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("\{\"2\":1234}\" will have a parent which have a long number\n");
int main(void) { int i, j; Wilddog_T p_repo1_ref1 = 0, p_repo1_ref2 =0; Wilddog_T p_repo2_ref1 = 0, p_repo2_ref2 = 0,p_repo2_ref1_cpy = 0; Wilddog_T p_ref[6]; Wilddog_T p_parent = 0, p_root = 0, p_child = 0; for(j = 0; j < FUNC_NUM; j++) { memset(&test_results[j], 0, sizeof(struct test_reult_t)); } test_results[0].name = "wilddog_getParent"; test_results[1].name = "wilddog_getRoot"; test_results[2].name = "wilddog_getChild"; /* * test the url format */ for( i = 0; i < sizeof(test_url)/sizeof(char *); i++) { p_ref[i] = wilddog_initWithUrl((Wilddog_Str_T *)test_url[i]); if(p_ref[i]) { wilddog_debug_level(WD_DEBUG_LOG, "p_ref-- [%d] \n\n", i); wilddog_debug_printUrl(p_ref[i]); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } else { wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n"); wilddog_debug_level(WD_DEBUG_LOG, "%s could not init\n\n", test_url[i]); wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n"); TEST_RESULT_PRINTF("test_all:wilddog_initWithUrl error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url before\n\n"); for( i = 0; i < sizeof(test_url)/sizeof(char *); i++) { wilddog_debug_level(WD_DEBUG_LOG, "destroy %d test url %lu\n", i, (long unsigned int)p_ref[i]); if(p_ref[i]) wilddog_destroy(&(p_ref[i])); } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url after\n\n"); /* * test the multi repo and multi ref * test getparent getchild getroot */ p_repo1_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1"); p_repo1_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1/b2"); p_repo2_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3"); p_repo2_ref1_cpy = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3"); p_repo2_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3/d4/e5"); if(p_repo1_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref1\n\n"); wilddog_debug_printUrl(p_repo1_ref1); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo1_ref2) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2\n\n"); wilddog_debug_printUrl(p_repo1_ref2); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo2_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref1\n\n"); wilddog_debug_printUrl(p_repo2_ref1); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo2_ref1 != p_repo2_ref1_cpy) { TEST_RESULT_PRINTF( "test_all: new same url error ",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } if(p_repo2_ref2) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2\n\n"); wilddog_debug_printUrl(p_repo2_ref2); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } p_parent = wilddog_getParent(p_repo1_ref2); if(p_parent == p_repo1_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--parent\n\n"); wilddog_debug_printUrl(p_parent); test_results[0].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's parent\n\n"); TEST_RESULT_PRINTF("test_all:get parent error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } p_root = wilddog_getRoot(p_repo1_ref2); if(p_root) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--root\n\n"); wilddog_debug_printUrl(p_root); test_results[1].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_root); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's root\n\n"); TEST_RESULT_PRINTF("test_all:get root error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } wilddog_debug_level(WD_DEBUG_LOG, "p_repo1_ref1 = %u",( unsigned int)p_repo1_ref1); wilddog_debug_printUrl(p_repo1_ref1); p_child = wilddog_getChild(p_repo2_ref2, (Wilddog_Str_T *)"c3/d4"); wilddog_debug_level(WD_DEBUG_LOG, "p_child = %u", ( unsigned int)p_child); if(p_child) { wilddog_debug_level(WD_DEBUG_LOG, "p_repo2_ref2--child\n\n"); wilddog_debug_printUrl(p_child); test_results[2].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_child); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get p_repo2_ref2's child /c3/d4\n\n"); TEST_RESULT_PRINTF("test_all:get chile error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } p_parent = wilddog_getParent(p_repo2_ref2); if(p_parent) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2--parent\n\n"); wilddog_debug_printUrl(p_parent); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_parent); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo2_ref2's parent\n\n"); } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy all ref\n\n"); wilddog_destroy(&p_repo1_ref1); wilddog_destroy(&p_repo1_ref2); wilddog_destroy(&p_repo2_ref1); wilddog_destroy(&p_repo2_ref2); for(j = 0 ; j < FUNC_NUM; j++) { if(test_results[j].name) { printf("%-32s\t%s\n", test_results[j].name, (test_results[j].result == TRUE?("PASS"):("FAIL"))); if(test_results[j].result != TRUE) return -1; } } return 0; }