Index: /trunk/psLib/src/types/psMetadata.c =================================================================== --- /trunk/psLib/src/types/psMetadata.c (revision 8413) +++ /trunk/psLib/src/types/psMetadata.c (revision 8414) @@ -12,6 +12,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.124 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-08-16 03:28:13 $ + * @version $Revision: 1.125 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-08-18 00:21:59 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -102,11 +102,11 @@ static void metadataItemFree(psMetadataItem* metadataItem) { - psDataType type; - - type = metadataItem->type; - if (metadataItem == NULL) { return; } + psDataType type; + + type = metadataItem->type; + psMemDecrRefCounter(metadataItem->name); Index: /trunk/psLib/test/types/Makefile.am =================================================================== --- /trunk/psLib/test/types/Makefile.am (revision 8413) +++ /trunk/psLib/test/types/Makefile.am (revision 8414) @@ -33,5 +33,7 @@ tap_psMetadataItemParse \ tap_psMetadata_printing \ - tap_psMetadata_copying + tap_psMetadata_copying \ + tap_psMetadata_creating \ + tap_psMetadata_manip @@ -77,4 +79,10 @@ tap_psMetadata_copying_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src tap_psMetadata_copying_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la + +tap_psMetadata_creating_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src +tap_psMetadata_creating_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la + +tap_psMetadata_manip_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src +tap_psMetadata_manip_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la check_DATA = \ Index: /trunk/psLib/test/types/execute_tap =================================================================== --- /trunk/psLib/test/types/execute_tap (revision 8414) +++ /trunk/psLib/test/types/execute_tap (revision 8414) @@ -0,0 +1,10 @@ +make tests +./tap_psListIterator +./tap_psMetadataConfigParse +./tap_psMetadata_copying +./tap_psMetadata_creating +./tap_psMetadataItemCompare +./tap_psMetadataItemParse +./tap_psMetadataIterator +./tap_psMetadata_manip +./tap_psMetadata_printing Index: /trunk/psLib/test/types/tap_psMetadataItemParse.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadataItemParse.c (revision 8413) +++ /trunk/psLib/test/types/tap_psMetadataItemParse.c (revision 8414) @@ -73,5 +73,5 @@ //Return 1.666 for string with "1.666" - ok ( psMetadataItemParseF32(itemString2) == 1.666, + ok ( abs(psMetadataItemParseF32(itemString2)-1.666) < FLT_EPSILON, "return 1.666 in F32 for string-item with value '1.666'." ); @@ -112,5 +112,5 @@ //Return 1.666 for string with "1.666" - ok ( psMetadataItemParseF64(itemString2) == 1.666, + ok ( abs(psMetadataItemParseF64(itemString2)-1.666) < DBL_EPSILON, "return 1.666 in F64 for string-item with value '1.666'." ); @@ -151,6 +151,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseS8(itemString2) == 2, - "return 2 in S8 for string-item with value '1.666'." ); + ok ( psMetadataItemParseS8(itemString2) == 1, + "return 1 in S8 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -158,6 +158,6 @@ "return 0 in S8 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS8(itemF64) == 1, - "return 1 in S8 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseS8(itemF64) == 0, + "return 0 in S8 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseS8(itemS8) == 1, @@ -190,6 +190,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseS16(itemString2) == 2, - "return 2 in S16 for string-item with value '1.666'." ); + ok ( psMetadataItemParseS16(itemString2) == 1, + "return 1 in S16 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -197,6 +197,6 @@ "return 0 in S16 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS16(itemF64) == 1, - "return 1 in S16 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseS16(itemF64) == 0, + "return 0 in S16 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseS16(itemS8) == 1, @@ -229,6 +229,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseS32(itemString2) == 2, - "return 2 in S32 for string-item with value '1.666'." ); + ok ( psMetadataItemParseS32(itemString2) == 1, + "return 1 in S32 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -236,6 +236,6 @@ "return 0 in S32 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS32(itemF64) == 1, - "return 1 in S32 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseS32(itemF64) == 0, + "return 0 in S32 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseS32(itemS8) == 1, @@ -268,6 +268,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseU8(itemString2) == 2, - "return 2 in U8 for string-item with value '1.666'." ); + ok ( psMetadataItemParseU8(itemString2) == 1, + "return 1 in U8 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -275,6 +275,6 @@ "return 0 in U8 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU8(itemF64) == 1, - "return 1 in U8 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseU8(itemF64) == 0, + "return 0 in U8 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseU8(itemS8) == 1, @@ -307,6 +307,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseU16(itemString2) == 2, - "return 2 in U16 for string-item with value '1.666'." ); + ok ( psMetadataItemParseU16(itemString2) == 1, + "return 1 in U16 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -314,6 +314,6 @@ "return 0 in U16 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU16(itemF64) == 1, - "return 1 in U16 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseU16(itemF64) == 0, + "return 0 in U16 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseU16(itemS8) == 1, @@ -346,6 +346,6 @@ //Return 2 for string with "1.666" - ok ( psMetadataItemParseU32(itemString2) == 2, - "return 2 in U32 for string-item with value '1.666'." ); + ok ( psMetadataItemParseU32(itemString2) == 1, + "return 1 in U32 for string-item with value '1.666'." ); //Return 0 for F32 value 0.0 @@ -353,6 +353,6 @@ "return 0 in U32 for F32-item with value '0.0'." ); //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU32(itemF64) == 1, - "return 1 in U32 for F64-item with value '0.5'." ); + ok ( psMetadataItemParseU32(itemF64) == 0, + "return 0 in U32 for F64-item with value '0.5'." ); //Return 1 for S8 value 1 ok ( psMetadataItemParseU32(itemS8) == 1, Index: /trunk/psLib/test/types/tap_psMetadata_creating.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8414) +++ /trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8414) @@ -0,0 +1,367 @@ +/** +* C Implementation: tap_psMetadata_creating +* +* Description: +* +* +* Author: dRob , (C) 2006 +* +* Copyright: See COPYING file that comes with this distribution +* +*/ + +#include "pstap.h" + +void testItemAllocs(void); +void testMDAlloc_AddItem(void); + +int main(void) +{ + plan_tests(31); + + diag("psMetadata & psMetadataItem Creation Functions"); + + testItemAllocs(); + testMDAlloc_AddItem(); + + done(); +} + +void testItemAllocs(void) +{ + diag("\n >>>Test 1: psMetadataItemAlloc & Free Fxns"); + psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr"); + psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66); + psMetadataItem *itemF64 = psMetadataItemAllocF64("itemF64", "", 0.666); + psMetadataItem *itemS8 = psMetadataItemAllocS8("itemS8", "", 0); + psMetadataItem *itemS16 = psMetadataItemAllocS16("itemS16", "", 1); + psMetadataItem *itemS32 = psMetadataItemAllocS32("itemS32", "", 2); + psMetadataItem *itemS64 = psMetadataItemAllocS64("itemS64", "", 3); + psMetadataItem *itemU8 = psMetadataItemAllocU8("itemU8", "", 0); + psMetadataItem *itemU16 = psMetadataItemAllocU16("itemU16", "", 1); + psMetadataItem *itemU32 = psMetadataItemAllocU32("itemU32", "", 2); + psMetadataItem *itemU64 = psMetadataItemAllocU64("itemU64", "", 3); + psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true); + + //Verify correct allocation + //String + { + skip_start(itemStr == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocStr() failed"); + ok(itemStr->type == PS_DATA_STRING + && !strncmp(itemStr->name, "itemStr", 10) + && !strncmp(itemStr->data.V, "itemStr", 10) + && !strncmp(itemStr->comment, "", 2), + "psMetadataItemAllocStr: create valid string item."); + skip_end(); + } + //F32 + { + skip_start(itemF32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocF32() failed"); + ok(itemF32->type == PS_DATA_F32 + && !strncmp(itemF32->name, "itemF32", 10) + && abs(itemF32->data.F32 - 6.66) < FLT_EPSILON + && !strncmp(itemF32->comment, "", 2), + "psMetadataItemAllocF32: create valid F32 item."); + skip_end(); + } + //F64 + { + skip_start(itemF64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocF64() failed"); + ok(itemF64->type == PS_DATA_F64 + && !strncmp(itemF64->name, "itemF64", 10) + && abs(itemF64->data.F64 - 0.666) < DBL_EPSILON + && !strncmp(itemF64->comment, "", 2), + "psMetadataItemAllocF64: create valid F64 item."); + skip_end(); + } + //S8 + { + skip_start(itemS8 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS8() failed"); + ok(itemS8->type == PS_DATA_S8 + && !strncmp(itemS8->name, "itemS8", 10) + && itemS8->data.S8 == 0 + && !strncmp(itemS8->comment, "", 2), + "psMetadataItemAllocS8: create valid S8 item."); + skip_end(); + } + //S16 + { + skip_start(itemS16 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS16() failed"); + ok(itemS16->type == PS_DATA_S16 + && !strncmp(itemS16->name, "itemS16", 10) + && itemS16->data.S16 == 1 + && !strncmp(itemS16->comment, "", 2), + "psMetadataItemAllocS16: create valid S16 item."); + skip_end(); + } + //S32 + { + skip_start(itemS32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS32() failed"); + ok(itemS32->type == PS_DATA_S32 + && !strncmp(itemS32->name, "itemS32", 10) + && itemS32->data.S32 == 2 + && !strncmp(itemS32->comment, "", 2), + "psMetadataItemAllocS32: create valid S32 item."); + skip_end(); + } + //S64 + { + skip_start(itemS64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS64() failed"); + ok(itemS64->type == PS_DATA_S64 + && !strncmp(itemS64->name, "itemS64", 10) + && itemS64->data.S64 == 3 + && !strncmp(itemS64->comment, "", 2), + "psMetadataItemAllocS64: create valid S64 item."); + skip_end(); + } + //U8 + { + skip_start(itemU8 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU8() failed"); + ok(itemU8->type == PS_DATA_U8 + && !strncmp(itemU8->name, "itemU8", 10) + && itemU8->data.U8 == 0 + && !strncmp(itemU8->comment, "", 2), + "psMetadataItemAllocU8: create valid U8 item."); + skip_end(); + } + //U16 + { + skip_start(itemU16 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU16() failed"); + ok(itemU16->type == PS_DATA_U16 + && !strncmp(itemU16->name, "itemU16", 10) + && itemU16->data.U16 == 1 + && !strncmp(itemU16->comment, "", 2), + "psMetadataItemAllocU16: create valid U16 item."); + skip_end(); + } + //U32 + { + skip_start(itemU32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU32() failed"); + ok(itemU32->type == PS_DATA_U32 + && !strncmp(itemU32->name, "itemU32", 10) + && itemU32->data.U32 == 2 + && !strncmp(itemU32->comment, "", 2), + "psMetadataItemAllocU32: create valid U32 item."); + skip_end(); + } + //U64 + { + skip_start(itemU64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU64() failed"); + ok(itemU64->type == PS_DATA_U64 + && !strncmp(itemU64->name, "itemU64", 10) + && itemU64->data.U64 == 3 + && !strncmp(itemU64->comment, "", 2), + "psMetadataItemAllocU64: create valid U64 item."); + skip_end(); + } + //Bool + { + skip_start(itemBool == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocBool() failed"); + ok(itemBool->type == PS_DATA_BOOL + && !strncmp(itemBool->name, "itemBool", 10) + && itemBool->data.B + && !strncmp(itemBool->comment, "", 2), + "psMetadataItemAllocBool: create valid Bool item."); + skip_end(); + } + + //Allocate a pointer. Example= psSphere + { + psSphere *s = psSphereAlloc(); + s->r = 1.1; + s->d = 2.1; + psMetadataItem *itemPtr = psMetadataItemAllocPtr("itemPtr", PS_DATA_SPHERE, "", s); + skip_start(itemPtr == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocPtr() failed"); + float r = ((psSphere*)(itemPtr->data.V))->r; + float d = ((psSphere*)(itemPtr->data.V))->d; + ok( itemPtr->type == PS_DATA_SPHERE + && !strncmp(itemPtr->name, "itemPtr", 10) + && abs(r-1.1) < FLT_EPSILON && abs(d-2.1) < FLT_EPSILON + && !strncmp(itemPtr->comment, "", 2), + "psMetadataItemAllocPtr: create valid ptr (psSphere) item."); + skip_end(); + psFree(s); + psFree(itemPtr); + } + + //Try to Allocate an unsupported type with AllocV + { + psMetadataItem *itemNULL = NULL; + psLine *line = psLineAlloc(2); + itemNULL = psMetadataItemAlloc("itemNULL", PS_DATA_LINE, NULL, line); + ok( itemNULL == NULL, + "psMetadataItemAlloc: return NULL for unsupported type."); + psFree(line); + } + + //Now Allocate the item with Alloc and test MemCheck for it's type. + { + psMetadataItem *itemAllocV = psMetadataItemAlloc("itemAllocV", PS_DATA_S32, NULL, 4); + skip_start(itemAllocV == NULL, 2, + "Skipping 2 tests because psMetadataItemAllocV() failed"); + ok (itemAllocV->type == PS_DATA_S32 + && !strncmp(itemAllocV->name, "itemAllocV", 10) + && itemAllocV->data.S32 == 4 + && !strncmp(itemAllocV->comment, "", 2), + "psMetadataItemAlloc: create valid S32 item."); + ok ( psMemCheckMetadataItem(itemAllocV), + "psMemCheckMetadataItem: return true for valid MetadataItem."); + skip_end(); + psFree(itemAllocV); + } + + //Make sure MemCheckItem worked. Try primitive type. Expect false. + { + int j = 2; + ok( !psMemCheckMetadataItem(&j), + "psMemCheckMetadataItem: return false for non-MetadataItem input."); + } + + //Create a null metadataItem and attempt to free it. (test for metadataItemFree) + psMetadataItem *item = NULL; + psFree(item); + //Check for Memory Leaks + { + psFree(itemStr); + psFree(itemF32); + psFree(itemF64); + psFree(itemS8); + psFree(itemS16); + psFree(itemS32); + psFree(itemS64); + psFree(itemU8); + psFree(itemU16); + psFree(itemU32); + psFree(itemU64); + psFree(itemBool); + checkMem(); + } + +} + +void testMDAlloc_AddItem(void) +{ + diag("\n >>>Test 2: psMetadataAlloc & Free Fxns"); + psMetadata *md = NULL; + //Attempt to free a null metadata + psFree(md); + md = psMetadataAlloc(); + psMetadata *md1 = psMetadataAlloc(); + psMetadata *md2 = psMetadataAlloc(); + //test MemCheck for a valid psMetadata + { + ok( psMemCheckMetadata(md), + "psMemCheckMetadata: return true for valid Metadata."); + } + //Make sure MemCheck worked. Try primitive type. Expect false. + { + int j = 2; + ok( !psMemCheckMetadata(&j), + "psMemCheckMetadata: return false for non-Metadata input."); + } + + diag("\n >>>Test 3: psMetadataAddItem"); + //Return false for NULL metadata input + psMetadataItem *item = psMetadataItemAllocBool("item", "", true); + { + ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for NULL metadata input."); + } + //Return false for metadata with NULL hash + psFree(md1->hash); + md1->hash = NULL; + { + ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for metadata with no hash."); + } + psFree(md1); + //Return false for metadata with NULL list + psFree(md2->list); + md2->list = NULL; + { + ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for metadata with no list."); + } + psFree(md2); + //Return false for NULL psMetadataItem input + { + ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for NULL item input."); + } + //Return false for psMetadataItem with NULL name + psFree(item->name); + item->name = NULL; + { + ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for item with no name."); + } + psFree(item); + + //item type=PS_DATA_METADATA_MULTI + // psMetadataAddS32(md, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); + psMetadata *itemMD = psMetadataAlloc(); + psMetadataAddS32(itemMD, PS_LIST_HEAD, "", PS_META_DUPLICATE_OK, "", 2); + psMetadataItem *item2 = psMetadataItemAlloc("multi", PS_DATA_METADATA_MULTI, "", itemMD); + + //Return true for addition of multi + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); + } + printf("\n >>Memory leakage coming from above test for METADATA_MULTI\n\n"); + psFree(item2); + psFree(itemMD); + + //Existing entry with duplicate key found. + psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1); + item2 = psMetadataItemAllocS32("S32", "", 1); + //FLAG = PS_META_DUPLICATE_OK + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for PS_META_DUPLICATE_OK flag."); + } + //FLAG = PS_META_REPLACE + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE), + "psMetadataAddItem: return true for PS_META_REPLACE flag."); + } + //FLAG = PS_META_NO_REPLACE + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE), + "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); + } + //FLAG = PS_META_DEFAULT + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT), + "psMetadataAddItem: return false for PS_META_DEFAULT flag."); + } + + //No existing entries or duplicates found + psFree(item2); + item2 = psMetadataItemAllocS32("new", "", 2); + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for new item."); + } + + //Check for Memory leaks + { + psFree(item2); + psFree(md); + checkMem(); + } +} + Index: /trunk/psLib/test/types/tap_psMetadata_manip.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_manip.c (revision 8414) +++ /trunk/psLib/test/types/tap_psMetadata_manip.c (revision 8414) @@ -0,0 +1,23 @@ +/** + * C Implementation: tap_psMetadata_manip + * +* Description: + * + * + * Author: dRob , (C) 2006 + * + * Copyright: See COPYING file that comes with this distribution + * + */ + +#include "pstap.h" + +int main(void) +{ + plan_tests(2); + + diag("psMetadataLookup and Remove Fxns"); + + + done(); +} Index: /trunk/psLib/test/types/tap_psMetadata_printing.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_printing.c (revision 8413) +++ /trunk/psLib/test/types/tap_psMetadata_printing.c (revision 8414) @@ -4,208 +4,15 @@ static psMetadata *setupMeta(void); +void testMetaPrint(void); +void testMetaItemPrint(void); int main(void) { - FILE *fd = fopen("psMetadataPrint.out", "w"); - FILE *fd_read = fopen("Makefile", "r"); - psMetadata *md = NULL; - psMetadata *md2 = NULL; - md = setupMeta(); - md2 = psMetadataAlloc(); - psSphere *sphere = psSphereAlloc(); - psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); - psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere); - plan_tests(30); - diag("psMetadataPrint and psMetadataItemPrint tests\n>>Test 1: psMetadataPrint"); - - //Return false for NULL psMetadata input - { - ok( !psMetadataPrint(NULL, NULL, 0), - "psMetadataPrint: return false for NULL psMetadata input."); - } - //Return false for read-only file descriptor - { - ok ( !psMetadataPrint(fd_read, md, 0), - "psMetadataPrint: return false for read-only file descriptor."); - } - fclose(fd_read); - //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN - { - ok ( psMetadataPrint(NULL, md2, 0), - "psMetadataPrint: return true for metadata with unknown datatype."); - } - psFree(md2); - - //Return false for unsupported vector type (C32) - md2 = psMetadataAlloc(); - psVector *vector = psVectorAlloc(2, PS_TYPE_C32); - psMetadataAddVector(md2, PS_LIST_HEAD, "name here", 0, "I vector", vector); - { - ok ( !psMetadataPrint(NULL, md2, 2), - "psMetadataPrint: return false for metadata with unknown vector-type."); - } - psFree(vector); - psFree(md2); - - //Valid case where fd is NULL -> stdout - md2 = psMetadataAlloc(); - psMetadataAddStr(md2, PS_LIST_HEAD, - " >>Hello Wally", 0, "My name is Bubbles", "Pet Me"); - { - ok ( psMetadataPrint(NULL, md2, 0), - "psMetadataPrint: return true for NULL file pointer."); - } - psFree(md2); - //Valid case where fd is "psMetadataPrint.out" - { - ok ( psMetadataPrint(fd, md, 0), - "psMetadataPrint: return true for file='psMetadataPrint.out'."); - } - fclose(fd); - - printf("\n"); - diag(">>Test2: psMetadataItemPrint"); - //bool psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* item) - fd = fopen("psMetadataItemPrint.out", "w"); - psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); - psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601); - psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this"); - psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1); - psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a"); - - //Return false for NULL file-pointer - { - ok( !psMetadataItemPrint(NULL, "%s", item1), - "psMetadataItemPrint: return false for NULL FILE*."); - } - //Return false for NULL format paramter - { - ok( !psMetadataItemPrint(fd, NULL, item1), - "psMetadataItemPrint: return false for NULL format."); - } - //Return false for NULL metadataItem - { - ok( !psMetadataItemPrint(fd, "%s", NULL), - "psMetadataItemPrint: return false for NULL psMetadataItem."); - } - //Return false for incorrect format parameter - { - ok( !psMetadataItemPrint(fd, "sos \n", item1), - "psMetadataItemPrint: return false for incorrect format."); - } - //Return false for type that doesn't match format (ie, %s for f32 value) - { - ok( !psMetadataItemPrint(fd, "%s", item2), - "psMetadataItemPrint: return false for item that doesn't match format."); - } - - //Return false for incorrect format parameter - { - ok( !psMetadataItemPrint(fd, "%z", item1), - "psMetadataItemPrint: return false for incorrect format."); - } - - - //Return true for format parameter containing additional modifiers (F32) - { - ok( psMetadataItemPrint(fd, "%.3f\n", item2), - "psMetadataItemPrint: return true for format with .3 modifier."); - } - //Return true for valid string input - { - ok( psMetadataItemPrint(fd, "%s\n", item3), - "psMetadataItemPrint: return true for valid string case w/s."); - } - //Return true for valid ptr input - { - ok( psMetadataItemPrint(fd, "%p\n", item3), - "psMetadataItemPrint: return true for valid ptr case w/p."); - } - - //Return true for format = %d, type = int - { - ok( psMetadataItemPrint(fd, "%d\n", item4), - "psMetadataItemPrint: return true for valid case w/d."); - } - //Return true for format = %i, type = int - { - ok( psMetadataItemPrint(fd, "%i\n", item4), - "psMetadataItemPrint: return true for valid case w/i."); - } - //Return true for format = %c, type = int - { - ok( psMetadataItemPrint(fd, "%c\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - //Return true for format = %o, type = int - { - ok( psMetadataItemPrint(fd, "%o\n", item4), - "psMetadataItemPrint: return true for valid case w/d."); - } - //Return true for format = %u, type = int - { - ok( psMetadataItemPrint(fd, "%u\n", item4), - "psMetadataItemPrint: return true for valid case w/i."); - } - //Return true for format = %x, type = int - { - ok( psMetadataItemPrint(fd, "%x\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - //Return true for format = %X, type = int - { - ok( psMetadataItemPrint(fd, "%X\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - - //Return true for format = %e, type = int - { - ok( psMetadataItemPrint(fd, "%.1e\n", item2), - "psMetadataItemPrint: return true for valid case w/e."); - } - //Return true for format = %E, type = int - { - ok( psMetadataItemPrint(fd, "%.2E\n", item2), - "psMetadataItemPrint: return true for valid case w/E."); - } - //Return true for format = %F, type = int - { - ok( psMetadataItemPrint(fd, "%.3F\n", item2), - "psMetadataItemPrint: return true for valid case w/F."); - } - //Return true for format = %g, type = int - { - ok( psMetadataItemPrint(fd, "%.3g\n", item2), - "psMetadataItemPrint: return true for valid case w/g."); - } - //Return true for format = %G, type = int - { - ok( psMetadataItemPrint(fd, "%.4G\n", item2), - "psMetadataItemPrint: return true for valid case w/G."); - } - //Return true for format = %a, type = int - { - ok( psMetadataItemPrint(fd, "%.4a\n", item2), - "psMetadataItemPrint: return true for valid case w/a."); - } - //Return true for format = %A, type = int - { - ok( psMetadataItemPrint(fd, "%A\n", item2), - "psMetadataItemPrint: return true for valid case w/A."); - } - - - //Check for Memory Leaks before exit - { - fclose(fd); - psFree(item1); - psFree(item2); - psFree(item3); - psFree(item4); - psFree(item5); - psFree(sphere); - psFree(md); - } + + diag("psMetadataPrint and psMetadataItemPrint tests"); + + testMetaPrint(); + testMetaItemPrint(); done(); @@ -327,5 +134,23 @@ psMetadataAddVector(md, PS_LIST_TAIL, "vector15", 0, "I am a F64-vector", vec); - + psImage *image = psImageAlloc(1, 1, PS_TYPE_S32); + psImageSet(image, 0, 0, 1); + psMetadataAddImage(md, PS_LIST_TAIL, "image1", 0, "I am an Image", image); + + psHash *hash = psHashAlloc(1); + psHashAdd(hash, "hash", image); + psMetadataAddHash(md, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash); + + psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0); + psMetadataAddLookupTable(md, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup); + + psArray *array = psArrayAlloc(1); + psArraySet(array, 0, image); + psMetadataAddArray(md, PS_LIST_TAIL, "array", 0, "I am an Array", array); + + psFree(array); + psFree(lookup); + psFree(image); + psFree(hash); psFree(region); psFree(list); @@ -337,2 +162,213 @@ } +void testMetaPrint(void) +{ + diag("\n >>Test 1: psMetadataPrint"); + FILE *fd = fopen("psMetadataPrint.out", "w"); + FILE *fd_read = fopen("Makefile", "r"); + psMetadata *md = NULL; + psMetadata *md2 = NULL; + md = setupMeta(); + md2 = psMetadataAlloc(); + psSphere *sphere = psSphereAlloc(); + psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); + psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere); + + //Return false for NULL psMetadata input + { + ok( !psMetadataPrint(NULL, NULL, 0), + "psMetadataPrint: return false for NULL psMetadata input."); + } + //Return false for read-only file descriptor + { + ok ( !psMetadataPrint(fd_read, md, 0), + "psMetadataPrint: return false for read-only file descriptor."); + } + fclose(fd_read); + //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN + { + ok ( psMetadataPrint(NULL, md2, 0), + "psMetadataPrint: return true for metadata with unknown datatype."); + } + psFree(md2); + + //Return false for unsupported vector type (C32) + md2 = psMetadataAlloc(); + psVector *vector = psVectorAlloc(2, PS_TYPE_C32); + psMetadataAddVector(md2, PS_LIST_HEAD, "name here", 0, "I vector", vector); + { + ok ( !psMetadataPrint(NULL, md2, 2), + "psMetadataPrint: return false for metadata with unknown vector-type."); + } + psFree(vector); + psFree(md2); + + //Valid case where fd is NULL -> stdout + md2 = psMetadataAlloc(); + psMetadataAddStr(md2, PS_LIST_HEAD, + " >>Hello Wally", 0, "My name is Bubbles", "Pet Me"); + { + ok ( psMetadataPrint(NULL, md2, 0), + "psMetadataPrint: return true for NULL file pointer."); + } + psFree(md2); + //Valid case where fd is "psMetadataPrint.out" + { + ok ( psMetadataPrint(fd, md, 0), + "psMetadataPrint: return true for file='psMetadataPrint.out'."); + } + + //Check for Memory Leaks before exit + { + fclose(fd); + psFree(sphere); + psFree(md); + checkMem(); + } +} + +void testMetaItemPrint(void) +{ + diag("\n >>Test2: psMetadataItemPrint"); + FILE *fd; + //bool psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* item) + fd = fopen("psMetadataItemPrint.out", "w"); + psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); + psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601); + psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this"); + psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1); + psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a"); + + //Return false for NULL file-pointer + { + ok( !psMetadataItemPrint(NULL, "%s", item1), + "psMetadataItemPrint: return false for NULL FILE*."); + } + //Return false for NULL format paramter + { + ok( !psMetadataItemPrint(fd, NULL, item1), + "psMetadataItemPrint: return false for NULL format."); + } + //Return false for NULL metadataItem + { + ok( !psMetadataItemPrint(fd, "%s", NULL), + "psMetadataItemPrint: return false for NULL psMetadataItem."); + } + //Return false for incorrect format parameter + { + ok( !psMetadataItemPrint(fd, "sos \n", item1), + "psMetadataItemPrint: return false for incorrect format."); + } + //Return false for type that doesn't match format (ie, %s for f32 value) + { + ok( !psMetadataItemPrint(fd, "%s", item2), + "psMetadataItemPrint: return false for item that doesn't match format."); + } + + //Return false for incorrect format parameter + { + ok( !psMetadataItemPrint(fd, "%z", item1), + "psMetadataItemPrint: return false for incorrect format."); + } + + + //Return true for format parameter containing additional modifiers (F32) + { + ok( psMetadataItemPrint(fd, "%.3f\n", item2), + "psMetadataItemPrint: return true for format with .3 modifier."); + } + //Return true for valid string input + { + ok( psMetadataItemPrint(fd, "%s\n", item3), + "psMetadataItemPrint: return true for valid string case w/s."); + } + //Return true for valid ptr input + { + ok( psMetadataItemPrint(fd, "%p\n", item3), + "psMetadataItemPrint: return true for valid ptr case w/p."); + } + + //Return true for format = %d, type = int + { + ok( psMetadataItemPrint(fd, "%d\n", item4), + "psMetadataItemPrint: return true for valid case w/d."); + } + //Return true for format = %i, type = int + { + ok( psMetadataItemPrint(fd, "%i\n", item4), + "psMetadataItemPrint: return true for valid case w/i."); + } + //Return true for format = %c, type = int + { + ok( psMetadataItemPrint(fd, "%c\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + //Return true for format = %o, type = int + { + ok( psMetadataItemPrint(fd, "%o\n", item4), + "psMetadataItemPrint: return true for valid case w/d."); + } + //Return true for format = %u, type = int + { + ok( psMetadataItemPrint(fd, "%u\n", item4), + "psMetadataItemPrint: return true for valid case w/i."); + } + //Return true for format = %x, type = int + { + ok( psMetadataItemPrint(fd, "%x\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + //Return true for format = %X, type = int + { + ok( psMetadataItemPrint(fd, "%X\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + + //Return true for format = %e, type = int + { + ok( psMetadataItemPrint(fd, "%.1e\n", item2), + "psMetadataItemPrint: return true for valid case w/e."); + } + //Return true for format = %E, type = int + { + ok( psMetadataItemPrint(fd, "%.2E\n", item2), + "psMetadataItemPrint: return true for valid case w/E."); + } + //Return true for format = %F, type = int + { + ok( psMetadataItemPrint(fd, "%.3F\n", item2), + "psMetadataItemPrint: return true for valid case w/F."); + } + //Return true for format = %g, type = int + { + ok( psMetadataItemPrint(fd, "%.3g\n", item2), + "psMetadataItemPrint: return true for valid case w/g."); + } + //Return true for format = %G, type = int + { + ok( psMetadataItemPrint(fd, "%.4G\n", item2), + "psMetadataItemPrint: return true for valid case w/G."); + } + //Return true for format = %a, type = int + { + ok( psMetadataItemPrint(fd, "%.4a\n", item2), + "psMetadataItemPrint: return true for valid case w/a."); + } + //Return true for format = %A, type = int + { + ok( psMetadataItemPrint(fd, "%A\n", item2), + "psMetadataItemPrint: return true for valid case w/A."); + } + + //Check for Memory Leaks before exit + { + fclose(fd); + psFree(item1); + psFree(item2); + psFree(item3); + psFree(item4); + psFree(item5); + checkMem(); + } +} +