slp_attr_test.c

SLP协议在linux下的实现。此版本为1.2.1版。官方网站为www.openslp.org

	/***** FIXME INSERT OPAQUE TESTING HERE. *****/


	/***** Test guessing facilities. *****/
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);

	/**** Single value. ****/
	err = SLPAttrSet_guess(attr, "tag", "string", SLP_REPLACE);
	assert(err == SLP_OK);

	err = SLPAttrGetType(attr, "tag", &type);
	assert(err == SLP_OK);
	assert(type == SLP_STRING);

	err = SLPAttrGet_str(attr, "tag", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 1);
	
	assert(strcmp(str_arr[0], "string") == 0);
	free(str_arr[0]);
	free(str_arr);
	
	/**** Multi value. ****/
	err = SLPAttrSet_guess(attr, "tag", "str1,str2", SLP_REPLACE);
	assert(err == SLP_OK);

	err = SLPAttrGetType(attr, "tag", &type);
	assert(err == SLP_OK);
	assert(type == SLP_STRING);

	err = SLPAttrGet_str(attr, "tag", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 2);
	
//	assert(strcmp(str_arr[0], "string") == 0);
	free(str_arr[0]);
	free(str_arr[1]);
	free(str_arr);
	SLPAttrFree(attr);
	
	
	/**** Test replacement of types. ****/
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);
	
	err = SLPAttrSet_keyw(attr, "keyw1"); /* Create. */
	assert(err == SLP_OK);
	
	err = SLPAttrGet_keyw(attr, "keyw1"); /* Test. */
	assert(err == SLP_OK);

	err = SLPAttrSet_bool(attr, "keyw1", SLP_TRUE); /* Create. */
	assert(err == SLP_OK);
	
	err = SLPAttrGet_keyw(attr, "keyw1"); /* Test. */
	assert(err == SLP_TYPE_ERROR);
	err = SLPAttrGet_bool(attr, "keyw1", &bool);
	assert(err == SLP_OK);
	assert(bool == SLP_TRUE);

	err = SLPAttrSet_int(attr, "keyw1", (int)1, SLP_ADD);
	assert(err == SLP_TYPE_ERROR);
	
	SLPAttrFree(attr);

	/**** Maintain two strings simultainiously. ****/
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);

	/**** Create. ****/
	err = SLPAttrSet_str(attr, "str", STR, SLP_ADD); 
	assert(err == SLP_OK);
	
	err = SLPAttrSet_str(attr, "str1", STR1, SLP_ADD); 
	assert(err == SLP_OK);

	/*** Test. ***/
	err = SLPAttrGet_str(attr, "str", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 1);
	assert(strcmp(str_arr[0], STR) == 0);
	free(str_arr[0]);
	free(str_arr);
	
	err = SLPAttrGet_str(attr, "str1", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 1);

	assert(strcmp(str_arr[0], STR1) == 0);
	free(str_arr[0]);
	free(str_arr);
	
	err = SLPAttrGet_str(attr, "str", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 1);

	assert(strcmp(str_arr[0], STR) == 0);
	free(str_arr[0]);
	free(str_arr);
	
	SLPAttrFree(attr);

	
	/**** Allocate from string. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(abool=false),keyw,(anInt=51,3)");
	assert(err == SLP_OK);

	err = SLPAttrGetType(attr, "abool", &type);
	assert(err == SLP_OK);
	assert(type == SLP_BOOLEAN);

	err = SLPAttrGet_bool(attr, "abool", &bool);
	assert(err == SLP_OK);
	assert(bool == SLP_FALSE);

	err = SLPAttrGetType(attr, "keyw", &type);
	assert(err == SLP_OK);
	assert(type == SLP_KEYWORD);

	err = SLPAttrGet_keyw(attr, "keyw"); 
	assert(err == SLP_OK);

	err = SLPAttrGetType(attr, "anInt", &type);
	assert(err == SLP_OK);
	assert(type == SLP_INTEGER);

	err = SLPAttrGet_int(attr, "anInt", &int_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 2);

	assert((int_arr[0] == 51 && int_arr[1] == 3) || (int_arr[0] == 3 && int_arr[1] == 51));

	free(int_arr);

	/*** Iterate across the thing. ***/
	err = SLPAttrIteratorAlloc(attr, &iter);
	assert(err == SLP_OK);

	while(SLPAttrIterNext(iter, (char const **)&tag, &type)== SLP_FALSE) {
	}
	SLPAttrIteratorFree(iter);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	
	/* FIXME Check str. */
	
	free(str);
	SLPAttrFree(attr);

	/**** Test freshen(). ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(abool=false),keyw,(anInt=51)");
	assert(err == SLP_OK);

	/*** Append without replacing. ***/
	err = SLPAttrFreshen(attr, "(cat=meow)");
	assert(err == SLP_OK);

	err = SLPAttrGet_str(attr, "cat", &str_arr, &len); 
	assert(err == SLP_OK);
	assert(len == 1);

	assert(strcmp(str_arr[0], "meow") == 0);
	free(str_arr[0]);
	free(str_arr);
	
	/*** Replace. ***/
	err = SLPAttrFreshen(attr, "(abool=true)");
	assert(err == SLP_OK);

	err = SLPAttrGet_bool(attr, "abool", &bool);
	assert(err == SLP_OK);
	assert(bool == SLP_TRUE);
	
	SLPAttrFree(attr);

	/**** Test the buffering for serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, SER1);
	assert(err == SLP_OK);

	/*** Try with too small a buffer.  ***/
	str2 = str = (char *)malloc(5);
	assert(str);
	assert(5 < strlen(SER1) + 1);
	err = SLPAttrSerialize(attr, NULL, &str, 5, NULL, SLP_FALSE);
	assert(str == str2); /* Ensure a new buffer wasn't created. */
	assert(err == SLP_BUFFER_OVERFLOW);
	free(str);

	/*** Try with a "just right" buffer. ***/
	str2 = str = (char *)malloc(strlen(SER1) + 1);
	assert(str);
	err = SLPAttrSerialize(attr, NULL, &str, strlen(SER1)+1, NULL, SLP_FALSE);
	assert(err == SLP_OK);
	assert(str == str2); /* Ensure a new buffer wasn't created. */
	assert(strstr(str, "(abool=false)") != NULL);
	assert(strstr(str, "keyw") != NULL);
	assert(strstr(str, "(anInt=51)") != NULL);
	assert(strlen(str) == 29);
	free(str);

	/*** Try with an "n-1" buffer. (too small) ***/
	str2 = str = (char *)malloc(strlen(SER1));
	assert(str);
	err = SLPAttrSerialize(attr, NULL, &str, strlen(SER1), NULL, SLP_FALSE);
	assert(err == SLP_BUFFER_OVERFLOW);
	free(str);

	SLPAttrFree(attr);

	/**** Test the freshening. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(abool=false),keyw,(anInt=51)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	assert(strstr(str, "(abool=false)") != NULL);
	assert(strstr(str, "keyw") != NULL);
	assert(strstr(str, "(anInt=51)") != NULL);
	assert(strlen(str) == 29);
	free(str);
	
	err = SLPAttrSet_bool(attr, "abool", SLP_FALSE);
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	assert(strcmp("(abool=false)", str) == 0);
	free(str);
	
	SLPAttrFree(attr);

	/**** Test serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(a=1)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	assert(strcmp(str, "(a=1)") == 0);
	free(str);
	
	SLPAttrFree(attr);

	
	/**** Test serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(a=0)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	assert(strcmp(str, "(a=0)") == 0);
	free(str);
	
	SLPAttrFree(attr);

	/**** Test serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(a=-1)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_TRUE);
	assert(err == SLP_OK);
	assert(strcmp(str, "(a=-1)") == 0);
	free(str);
	
	SLPAttrFree(attr);

	/**** Test serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(a=52)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);
	assert(strcmp(str, "(a=52)") == 0);
	free(str);
	
	SLPAttrFree(attr);

	/**** Test serialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(a=-2000)");
	assert(err == SLP_OK);

	str = NULL;
	err = SLPAttrSerialize(attr, NULL, &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);
	assert(strcmp(str, "(a=-2000)") == 0);
	free(str);
	
	SLPAttrFree(attr);

	/**** Do it again. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(public=log),(slug=pig),(doc=12,34,56),zoink");
	assert(err == SLP_OK);
	
	assert(test_int(attr, "doc", (int)12, (int)34, (int)56, TERM_INT));

	/*** Test singular desrialization. ***/
	str = NULL;
	err = SLPAttrSerialize(attr, "doc", &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check that serialized values are there. */
	assert(strstr(str, "12") != NULL);
	assert(strstr(str, "34") != NULL);
	assert(strstr(str, "56") != NULL);
	assert(strstr(str, "doc") != NULL);
	
	/* Check that other tags aren't. */
	assert(strstr(str, "public") == NULL);
	assert(strstr(str, "slug") == NULL);
	assert(strstr(str, "zoink") == NULL);

	free(str);
	
	/*** Test binary deserialization. ***/
	str = NULL;
	err = SLPAttrSerialize(attr, "doc,zoink", &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check that serialized values are there. */
	assert(strstr(str, "12") != NULL);
	assert(strstr(str, "34") != NULL);
	assert(strstr(str, "56") != NULL);
	assert(strstr(str, "zoink") != NULL);
	assert(strstr(str, "doc") != NULL);

	/* Check that other tags aren't. */
	assert(strstr(str, "public") == NULL);
	assert(strstr(str, "slug") == NULL);

	free(str);


	/*** Test binary deserialization. ***/
	str = NULL;
	err = SLPAttrSerialize(attr, "doc,public", &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check that serialized values are there. */
	assert(strstr(str, "12") != NULL);
	assert(strstr(str, "34") != NULL);
	assert(strstr(str, "56") != NULL);
	assert(strstr(str, "log") != NULL);
	assert(strstr(str, "public") != NULL);

	/* Check that other tags aren't. */
	assert(strstr(str, "slug") == NULL);
	assert(strstr(str, "pig") == NULL);
	assert(strstr(str, "zoink") == NULL);

	free(str);
	
	
	/*** Test binary deserialization. ***/
	str = NULL;
	err = SLPAttrSerialize(attr, "doc,zoink,public", &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check that serialized values are there. */
	assert(strstr(str, "12") != NULL);
	assert(strstr(str, "34") != NULL);
	assert(strstr(str, "56") != NULL);
	assert(strstr(str, "zoink") != NULL);
	assert(strstr(str, "doc") != NULL);
	assert(strstr(str, "public=log") != NULL);

	/* Check that other tags aren't. */
	assert(strstr(str, "slug") == NULL);
	assert(strstr(str, "pig") == NULL);

	free(str);

	/*** Test binary deserialization. ***/
	str = NULL;
	err = SLPAttrSerialize(attr, "doc,zoink,public,slug", &str, 0, NULL, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check that serialized values are there. */
	assert(strstr(str, "12") != NULL);
	assert(strstr(str, "34") != NULL);
	assert(strstr(str, "56") != NULL);
	assert(strstr(str, "zoink") != NULL);
	assert(strstr(str, "doc") != NULL);
	assert(strstr(str, "public=log") != NULL);
	assert(strstr(str, "slug=pig") != NULL);

	assert(strlen(str) == 44);
	
	free(str);
	
	SLPAttrFree(attr);


	/**** Test deserialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(attr1=val1),(attr2=val1,val2),(attr3=val1,val2,val3)");
	assert(err == SLP_OK);

	/* Check that all values were deserialized. */
	assert(test_string(attr, "attr1", "val1", NULL));
	assert(test_string(attr, "attr2", "val1", "val2", NULL));
	assert(test_string(attr, "attr3", "val1", "val2", "val3", NULL));

	/* Check that there are no extra values. */
	assert(test_size(attr) == 3);
	
	SLPAttrFree(attr);
	
	
	/**** Test deserialization. ****/
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, "(attr1=val1),(attr2=val1,val2),(attr3=val1,val2,val3)");
	assert(err == SLP_OK);

	/* Check that all values were deserialized. */
	assert(test_string(attr, "attr1", "val1", NULL));
	assert(test_string(attr, "attr2", "val1", "val2", NULL));
	assert(test_string(attr, "attr3", "val1", "val2", "val3", NULL));

	/* Check that there are no extra values. */
	assert(test_size(attr) == 3);
	
	SLPAttrFree(attr);
	
	
	/**** Test deserialization. ****/
	str2 = "keyw1,keyw2,(ValX3=val1,val2,val3),(ints=12,3244,93,-15,2,-135),(aBool1=true),(aBool2=false)";
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, str2);
	assert(err == SLP_OK);

	/* Check that all values were deserialized. */
	assert(SLPAttrGet_keyw(attr, "keyw1") == SLP_OK);
	assert(SLPAttrGet_keyw(attr, "keyw2") == SLP_OK);
	assert(test_string(attr, "ValX3", "val1","val2","val3", NULL));
	assert(test_int(attr, "ints", 12, 3244, 93, -15, 2, -135, TERM_INT));
	assert(SLPAttrGet_bool(attr, "aBool1", &bool) == SLP_OK && bool == SLP_TRUE);
	assert(SLPAttrGet_bool(attr, "aBool2", &bool) == SLP_OK && bool == SLP_FALSE);

	/*** Test standard case of deserialization. ***/
	str = (char *)93; /* It's ok. it shouldn't write here, cause we pass a length of zero in. */
	err = SLPAttrSerialize(attr, NULL, &str, 0, &len, SLP_FALSE);
	assert(err == SLP_BUFFER_OVERFLOW);
	assert(strlen(str2) + 1 == len); /* +1 for null. */

	str = (char *)malloc(len);
	assert(str != NULL);
	/* Check for n+1 error. */
	err = SLPAttrSerialize(attr, NULL, &str, len, &len, SLP_FALSE);
	assert(err == SLP_OK);

	free(str);
	
	SLPAttrFree(attr);

	
	/*** Test that integers/strings are properly recognized. ***/
	str2 = "(int=1,2,3),(str=1,2-3)";
	err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &attr, str2);
	assert(err == SLP_OK);

	assert(test_string(attr, "str", "1","2-3", NULL));
	assert(test_int(attr, "int", 1, 2, 3, TERM_INT));
	
	SLPAttrFree(attr);
	
#else /* ENABLE_PREDICATES */
	printf("Predicates disabled. Performing partial test for libslpattr_tiny.c");

	
#endif /* ENABLE_PREDICATES */
	/***** Common tests. *****/
	
	/**** Basic creation. ****/
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);

	SLPAttrFree(attr);

	/**** Test deserialization. ****/
	str2 = "keyw1,keyw2,(ValX3=val1,val2,val3),(ints=12,3244,93,-15,2,-135),(aBool1=true),(aBool2=false)";
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);

	err = SLPAttrFreshen(attr, str2);
	assert(err == SLP_OK);
	
	/*** Test standard case of deserialization. ***/
	str = (char *)93; /* It's ok. it shouldn't write here, cause we pass a length of zero in. */
	err = SLPAttrSerialize(attr, NULL, &str, 0, &len, SLP_FALSE);
	assert(err == SLP_BUFFER_OVERFLOW);
	assert(strlen(str2) + 1 == len); /* +1 for null. */

	str = (char *)malloc(len);
	assert(str != NULL);
	/* Check for n+1 error. */
	err = SLPAttrSerialize(attr, NULL, &str, len, &len, SLP_FALSE);
	assert(err == SLP_OK);

	/* Check length of serialized. */
	assert(strlen(str) == strlen(str2));

	/* Check contents of serialized. */
	assert(strstr(str, "keyw1"));
	assert(strstr(str, "keyw2"));
	assert(strstr(str, "keyw2"));

	free(str);
	
	SLPAttrFree(attr);
	
	/**** Create and freshen. ****/
	str2 = "keyword,(aBool=true),(int=1,2,3,-4,1000,-2000),(str=val 1,val 2,val 3)";
	
	err = SLPAttrAlloc("en", NULL, SLP_FALSE, &attr);
	assert(err == SLP_OK);

	err = SLPAttrFreshen(attr, str2);
	assert(err == SLP_OK);

	/*** Check the serialized attribute string. ***/
	assert(test_serialized(str2, "aBool", "true", NULL));
	assert(test_serialized(str2, "int", "1", "2", "3", "-4", "1000", "-2000", NULL));
	assert(test_serialized(str2, "str", "val 1", "val 2", "val 3", NULL));
	
	
	SLPAttrFree(attr);

	
	return 0;
}