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);
	}

}
Beispiel #4
0
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;
}
Beispiel #5
0
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;
}
Beispiel #9
0
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;

}
Beispiel #10
0
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;
}
Beispiel #13
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;
}
Beispiel #14
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;
}