示例#1
0
void set_receive_time(guu_is_wilddog_t *gwd)
{
	//set the unix time stamp in the tree we got
	char time_buf[14];
	int len;
	
	Wilddog_Node_T *node;
	
	node = wilddog_node_find(gwd->snapshot_clone,"received");
	if(node !=NULL)
	{
		gettimeofday(&tv, NULL);

		len = sprintf(time_buf,"%ld", tv.tv_sec);
		//printf("%s %d\n",time_buf,len);
		if( wilddog_node_setValue(node,time_buf,len) != 0)
		{
			wilddog_debug("setValue failed\n");
		}

	}
	

	wilddog_setValue(gwd->wd,gwd->snapshot_clone,setvalue_cb,(void*)gwd);

}
示例#2
0
STATIC void stab_settest_serialSet_send(void)
{
	int i,res;
	stab_settest_setsuccess = 0;
	for(i=0;i<10;i++)
	{
		res = wilddog_setValue(stab_setdata[i].client,\
				stab_setdata[i].p_node,stab_settest_serialSetValueFunc,\
				(void*)&stab_setdata[i]);
		stab_get_requestRes(res);
		if(res>=0)
		{
			stab_setdata[i].setfault = 0;
			//stab_settest_request++;
			stab_settest_setsuccess++;	
		}
		else
			stab_setdata[i].setfault=1;
	}
	while(1)
	{
 		if(stab_settest_setsuccess ==0 )
 			break;
		stab_trysync();
	}
}
STATIC int multipletest_request(MULTIPLETEST_CMD_TYPE type,
                                Wilddog_T client,Multiple_client_T *p_mul_client)
{

    Wilddog_Node_T *p_head = NULL,*p_node = NULL;
    int res = 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 *)MULTIPLETEST_KEY,(Wilddog_Str_T *)p_mul_client->p_host);

    /*Add p_node to p_head, then p_node is the p_head's child node*/
    wilddog_node_addChild(p_head, p_node);

    p_mul_client->d_cmd= type;
    p_mul_client->d_recvFlag = 0;
    p_mul_client->d_sendFault = 1;
    switch(type)
    {
    case MULTIPLETEST_CMD_GET:
        /*Send the query method*/
        res = wilddog_getValue(client, (onQueryFunc)multiple_getValueFunc, (void*)p_mul_client);
        break;
    case MULTIPLETEST_CMD_SET:
        /*Send the set method*/
        res = wilddog_setValue(client,p_head,multiple_setValueFunc,(void*)p_mul_client);
        break;
    case MULTIPLETEST_CMD_PUSH:
        /*Send the push method*/
        res = wilddog_push(client, p_head, multiple_pushFunc, (void *)p_mul_client);
        break;
    case MULTIPLETEST_CMD_DELE:
        /*Send the remove method*/
        res = wilddog_removeValue(client, multiple_removeValueFunc, (void*)p_mul_client);
        break;
    case MULTIPLETEST_CMD_ON:
        /*Observe on*/
        res = wilddog_addObserver(client, WD_ET_VALUECHANGE, multiple_addObserverFunc, (void*)p_mul_client);
        break;
    case MULTIPLETEST_CMD_OFF:
        res = wilddog_removeObserver(client, WD_ET_VALUECHANGE);
        break;
    case MULTIPLETEST_CMD_NON:
    default:
        break;
    }
    /*Delete the node*/
    wilddog_node_delete(p_head);
    /* fautl to request then do not getValue */
    if(res >= 0)
        p_mul_client->d_sendFault = 0;

    return res;
}
int stabtest_reques(STABTEST_CMD_TYPE type,Wilddog_T client,BOOL *p_finishFlag)
{

	Wilddog_Node_T *p_head = NULL,*p_node = NULL;
	int res = 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 *)STABTEST_KEY,(Wilddog_Str_T *)STABTEST_VALUE);
    
    /*Add p_node to p_head, then p_node is the p_head's child node*/
    wilddog_node_addChild(p_head, p_node);
	
    
	stab_cmd = type;
    switch(type)
    {
        case STABTEST_CMD_GET:
            /*Send the query method*/
            res = wilddog_getValue(client, (onQueryFunc)stab_getValueFunc, (void*)p_finishFlag);
            break;
        case STABTEST_CMD_SET:  
            /*Send the set method*/
            res = wilddog_setValue(client,p_head,stab_setValueFunc,(void*)p_finishFlag);
            break;
        case STABTEST_CMD_PUSH:
            /*Send the push method*/
            res = wilddog_push(client, p_head, stab_pushFunc, (void *)p_finishFlag);  
            break;
        case STABTEST_CMD_DELE:
            /*Send the remove method*/
            res = wilddog_removeValue(client, stab_removeValueFunc, (void*)p_finishFlag);
            break;
        case STABTEST_CMD_ON:
            /*Observe on*/
            res = wilddog_addObserver(client, WD_ET_VALUECHANGE, stab_addObserverFunc, (void*)p_finishFlag);
            break;
		case STABTEST_CMD_OFF:
			res = wilddog_removeObserver(client, WD_ET_VALUECHANGE);
			break;
		case STABTEST_CMD_NON:
		default:
			break;
    }
    /*Delete the node*/
    wilddog_node_delete(p_head);
    return res;
}
示例#5
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;

}
示例#6
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;
}
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;
}
示例#8
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");