Index: trunk/psLib/test/types/Makefile.am =================================================================== --- trunk/psLib/test/types/Makefile.am (revision 25256) +++ trunk/psLib/test/types/Makefile.am (revision 27303) @@ -29,5 +29,5 @@ tap_psPixels_all \ tap_psHash_all \ - tap_psBitSet_all \ + tap_psBits_all \ tap_psList_all \ tap_psLookupTable_all \ Index: trunk/psLib/test/types/tap_psBitSet_all.c =================================================================== --- trunk/psLib/test/types/tap_psBitSet_all.c (revision 25256) +++ (revision ) @@ -1,279 +1,0 @@ -/** - * C Implementation: tap_psBitSet_all - * - * Description: Tests for psBitSetAlloc, psBitSetSet, psMemCheckBitSet, psBitSetClear, - * psBitSetTest, psBitSetOp, psBitSetNot, psBitSetToString - * - * Author: dRob , (C) 2006 - * - * Copyright: See COPYING file that comes with this distribution - * - */ -#include -#include -#include "tap.h" -#include "pstap.h" - - -int main(void) -{ - psLogSetFormat("HLNM"); - psLogSetLevel(PS_LOG_INFO); - plan_tests(31); - - - // testBitSetBasics() - { - psMemId id = psMemGetId(); - psBitSet *noBits = NULL; - psBitSet *bs = NULL; - - //Return NULL for attempt to Allocate BitSet of negative size. - { - noBits = psBitSetAlloc(-1); - ok( noBits == NULL, - "psBitSetAlloc: return NULL for negative BitSet-size input."); - } - //Return properly allocated 0-size psBitSet - { - bs = psBitSetAlloc(0); - ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 0, - "psBitSetAlloc: return properly allocated psBitSet."); - } - //Return properly allocated psBitSet - { - psFree(bs); - bs = psBitSetAlloc(8); - ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 1, - "psBitSetAlloc: return properly allocated psBitSet."); - } - //Make sure psMemCheckBitSet works correctly - return false - if (0) { - int j = 2; - ok( !psMemCheckBitSet(&j), - "psMemCheckBitSet: return false for non-BitSet input."); - } - - //BitSetSet Tests - //Return FALSE for NULL input psBitSet - { - bool rc = psBitSetSet(NULL, 0); - ok(rc == false, - "psBitSetSet: return FALSE for NULL BitSet input."); - } - //Return FALSE for negative bit input - { - bool rc = psBitSetSet(bs, -1); - ok( rc == false, - "psBitSetSet: return TRUE for negative bits input."); - noBits = NULL; - } - //Return FALSE for out-of-range bits - { - psFree(bs); - bs = psBitSetAlloc(8); - bool rc = psBitSetSet(bs, 8); - ok( rc == false, - "psBitSetSet: return TRUE for out-of-range bits input."); - noBits = NULL; - } - - //Return set BitSet for valid inputs - { - psBitSetSet(bs, 2); - ok( bs->bits[0] == 4, - "psBitSetSet: return properly set BitSet for valid inputs."); - } - - //BitSetClear Tests - //Return FALSE for NULL input psBitSet - { - bool rc = psBitSetClear(noBits, 0); - ok( rc == false, - "psBitSetClear: return FALSE for NULL BitSet input."); - } - //Return FALSE for negative bit input - { - bool rc = psBitSetClear(bs, -1); - ok( rc == false, - "psBitSetClear: return TRUE for negative bits input."); - noBits = NULL; - } - //Return FALSE for out-of-range bits - { - bool rc = psBitSetClear(bs, 8); - ok( rc == false, - "psBitSetClear: return FALSE for out-of-range bits input."); - noBits = NULL; - } - - //Return cleared BitSet for valid inputs - { - psBitSetClear(bs, 2); - ok( bs->bits[0] == 0, - "psBitSetClear: return properly cleared BitSet for valid inputs."); - } - - //BitSetTest Tests - //Return false for NULL input psBitSet - { - ok( !psBitSetTest(noBits, 0), - "psBitSetTest: return false for NULL BitSet input."); - } - //Return false for negative bit input - { - ok( !psBitSetTest(bs, -1), - "psBitSetTest: return false for negative bits input."); - } - //Return false for out-of-range bits - { - ok( !psBitSetTest(bs, 8), - "psBitSetTest: return false for out-of-range bits input."); - } - //Return false for non-matching bit in BitSet - { - ok( !psBitSetTest(bs, 2), - "psBitSetTest: return false for non-matching bit in BitSet."); - } - //Return false for non-matching bit in BitSet - { - psBitSetSet(bs, 2); - ok( psBitSetTest(bs, 2), - "psBitSetTest: return true for matching bit in BitSet."); - } - - psFree(bs); - ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); - } - - - // testBitSetOps() - { - psMemId id = psMemGetId(); - psBitSet *noBits = NULL; - psBitSet *bs = NULL; - bs = psBitSetAlloc(8); - psBitSetSet(bs, 2); // 0000 0100 == 4 - psBitSetSet(bs, 3); // 0000 1100 == 12 - psBitSetSet(bs, 4); // 0001 1100 == 28 - psBitSetSet(bs, 5); // 0011 1100 == 60 - psBitSetSet(bs, 6); // 0111 1100 == 124 - psBitSetSet(bs, 7); // 1111 1100 == 252 - psBitSet *out = NULL; - - //psBitSetNot Tests - //Return NULL for NULL BitSet input - { - out = psBitSetNot(out, noBits); - ok( out == NULL, - "psBitSetNot: return NULL for NULL BitSet input."); - } - //Return correct BitSet for valid BitSet input - { - out = psBitSetNot(out, bs); //bs = 1111 1100 so out should = 0000 0011 = 3 - ok( out->bits[0] == 3, - "psBitSetNot: return correct BitSet for valid BitSet input."); - } - - //psBitSetOp Tests out = psBitSetOp(out, bs1, "op", bs2); - //Return NULL for NULL BitSet input - { - psFree(out); - out = NULL; - out = psBitSetOp(out, noBits, "op", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for NULL BitSet input."); - } - //Return NULL for NULL operator input - { - out = psBitSetOp(out, bs, NULL, noBits); - ok( out == NULL, - "psBitSetOp: return NULL for NULL operator input."); - } - //Return NULL for invalid operator input - { - out = psBitSetOp(out, bs, "XAND", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for invalid operator input."); - } - //Return NULL for AND operator with NULL second BitSet input - { - out = psBitSetOp(out, bs, "AND", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for AND operator with NULL second BitSet input."); - } - //Return NULL for AND operator with BitSet inputs of differing size. - psBitSet *bs2 = psBitSetAlloc(16); - { - out = psBitSetOp(out, bs, "AND", bs2); - ok( out == NULL, - "psBitSetOp: return NULL for AND operator with BitSet inputs of" - " differing size."); - } - psFree(bs); - bs = psBitSetAlloc(16); - psBitSetSet(bs, 1); // 0000 0010 == 2 - psBitSetSet(bs2, 2); // 0000 0100 == 4 - //Return correct psBitSet output for valid inputs with AND operator - { - out = psBitSetOp(out, bs, "AND", bs2); - ok( out->bits[0] == 0, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with AND operator."); - } - //Return correct psBitSet output for valid inputs with OR operator - { - out = psBitSetOp(out, bs, "OR", bs2); - ok( out->bits[0] == 6, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with OR operator."); - } - //Return correct psBitSet output for valid inputs with XOR operator - psBitSetSet(bs2, 1); // 0000 0110 == 6 - { - out = psBitSetOp(out, bs, "XOR", bs2); - ok( out->bits[0] == 4, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with XOR operator."); - } - //Return correct psBitSet output for valid inputs with NOT operator - { - psFree(out); - out = psBitSetAlloc(0); - psBitSetSet(bs, 2); // 0000 0110 == 4 - psBitSetSet(bs, 3); // 0000 1110 == 12 - psBitSetSet(bs, 4); // 0001 1110 == 28 - psBitSetSet(bs, 5); // 0011 1110 == 60 - psBitSetSet(bs, 6); // 0111 1110 == 124 - psBitSetSet(bs, 7); // 1111 1110 == 252 - out = psBitSetOp(out, bs, "NOT", bs2); - ok( out->bits[0] == 1, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with NOT operator."); - } - - //psBitSetToString Tests - //Return NULL for NULL BitSet input - psString bitStr = NULL; - { - bitStr = psBitSetToString(noBits); - ok( bitStr == NULL, - "psBitSetToString: return NULL for NULL BitSet input."); - } - //Return correct string for valid BitSet input - { - psFree(bs); - bs = psBitSetAlloc(8); - psBitSetSet(bs, 2); // 0000 0100 == 4 - bitStr = psBitSetToString(bs); - ok( !strncmp(bitStr, "00000100", 10), - "psBitSetToString: return correct string for valid BitSet input."); - } - - psFree(bitStr); - psFree(out); - psFree(bs); - psFree(bs2); - ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); - } -} Index: trunk/psLib/test/types/tap_psBits_all.c =================================================================== --- trunk/psLib/test/types/tap_psBits_all.c (revision 27303) +++ trunk/psLib/test/types/tap_psBits_all.c (revision 27303) @@ -0,0 +1,273 @@ +/** + * C Implementation: tap_psBits_all + * + * Description: Tests for psBitsAlloc, psBitsSet, psMemCheckBits, psBitsClear, + * psBitsTest, psBitsOp, psBitsNot, psBitsToString + * + * Author: dRob , (C) 2006 + * + * Copyright: See COPYING file that comes with this distribution + * + */ +#include +#include +#include "tap.h" +#include "pstap.h" + + +int main(void) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(30); + + + // testBitsBasics() + { + psMemId id = psMemGetId(); + psBits *noBits = NULL; + psBits *bs = NULL; + + //Return properly allocated 0-size psBits + { + bs = psBitsAlloc(0); + ok( bs != NULL && psMemCheckBits(bs) && bs->n == 0, + "psBitsAlloc: return properly allocated psBits."); + } + //Return properly allocated psBits + { + psFree(bs); + bs = psBitsAlloc(8); + ok( bs != NULL && psMemCheckBits(bs) && bs->n == 8, + "psBitsAlloc: return properly allocated psBits."); + } + //Make sure psMemCheckBits works correctly - return false + if (0) { + int j = 2; + ok( !psMemCheckBits(&j), + "psMemCheckBits: return false for non-Bits input."); + } + + //BitsSet Tests + //Return FALSE for NULL input psBits + { + bool rc = psBitsSet(NULL, 0); + ok(rc == false, + "psBitsSet: return FALSE for NULL Bits input."); + } + //Return FALSE for negative bit input + { + bool rc = psBitsSet(bs, -1); + ok( rc == false, + "psBitsSet: return TRUE for negative bits input."); + noBits = NULL; + } + //Return FALSE for out-of-range bits + { + psFree(bs); + bs = psBitsAlloc(8); + bool rc = psBitsSet(bs, 8); + ok( rc == false, + "psBitsSet: return TRUE for out-of-range bits input."); + noBits = NULL; + } + + //Return set Bits for valid inputs + { + psBitsSet(bs, 2); + ok( bs->bits[0] == 4, + "psBitsSet: return properly set Bits for valid inputs."); + } + + //BitsClear Tests + //Return FALSE for NULL input psBits + { + bool rc = psBitsClear(noBits, 0); + ok( rc == false, + "psBitsClear: return FALSE for NULL Bits input."); + } + //Return FALSE for negative bit input + { + bool rc = psBitsClear(bs, -1); + ok( rc == false, + "psBitsClear: return TRUE for negative bits input."); + noBits = NULL; + } + //Return FALSE for out-of-range bits + { + bool rc = psBitsClear(bs, 8); + ok( rc == false, + "psBitsClear: return FALSE for out-of-range bits input."); + noBits = NULL; + } + + //Return cleared Bits for valid inputs + { + psBitsClear(bs, 2); + ok( bs->bits[0] == 0, + "psBitsClear: return properly cleared Bits for valid inputs."); + } + + //BitsTest Tests + //Return false for NULL input psBits + { + ok( !psBitsTest(noBits, 0), + "psBitsTest: return false for NULL Bits input."); + } + //Return false for negative bit input + { + ok( !psBitsTest(bs, -1), + "psBitsTest: return false for negative bits input."); + } + //Return false for out-of-range bits + { + ok( !psBitsTest(bs, 8), + "psBitsTest: return false for out-of-range bits input."); + } + //Return false for non-matching bit in Bits + { + ok( !psBitsTest(bs, 2), + "psBitsTest: return false for non-matching bit in Bits."); + } + //Return false for non-matching bit in Bits + { + psBitsSet(bs, 2); + ok( psBitsTest(bs, 2), + "psBitsTest: return true for matching bit in Bits."); + } + + psFree(bs); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testBitsOps() + { + psMemId id = psMemGetId(); + psBits *noBits = NULL; + psBits *bs = NULL; + bs = psBitsAlloc(8); + psBitsSet(bs, 2); // 0000 0100 == 4 + psBitsSet(bs, 3); // 0000 1100 == 12 + psBitsSet(bs, 4); // 0001 1100 == 28 + psBitsSet(bs, 5); // 0011 1100 == 60 + psBitsSet(bs, 6); // 0111 1100 == 124 + psBitsSet(bs, 7); // 1111 1100 == 252 + psBits *out = NULL; + + //psBitsNot Tests + //Return NULL for NULL Bits input + { + out = psBitsNot(out, noBits); + ok( out == NULL, + "psBitsNot: return NULL for NULL Bits input."); + } + //Return correct Bits for valid Bits input + { + out = psBitsNot(out, bs); //bs = 1111 1100 so out should = 0000 0011 = 3 + ok( out->bits[0] == 3, + "psBitsNot: return correct Bits for valid Bits input."); + } + + //psBitsOp Tests out = psBitsOp(out, bs1, "op", bs2); + //Return NULL for NULL Bits input + { + psFree(out); + out = NULL; + out = psBitsOp(out, noBits, "op", noBits); + ok( out == NULL, + "psBitsOp: return NULL for NULL Bits input."); + } + //Return NULL for NULL operator input + { + out = psBitsOp(out, bs, NULL, noBits); + ok( out == NULL, + "psBitsOp: return NULL for NULL operator input."); + } + //Return NULL for invalid operator input + { + out = psBitsOp(out, bs, "XAND", noBits); + ok( out == NULL, + "psBitsOp: return NULL for invalid operator input."); + } + //Return NULL for AND operator with NULL second Bits input + { + out = psBitsOp(out, bs, "AND", noBits); + ok( out == NULL, + "psBitsOp: return NULL for AND operator with NULL second Bits input."); + } + //Return NULL for AND operator with Bits inputs of differing size. + psBits *bs2 = psBitsAlloc(16); + { + out = psBitsOp(out, bs, "AND", bs2); + ok( out == NULL, + "psBitsOp: return NULL for AND operator with Bits inputs of" + " differing size."); + } + psFree(bs); + bs = psBitsAlloc(16); + psBitsSet(bs, 1); // 0000 0010 == 2 + psBitsSet(bs2, 2); // 0000 0100 == 4 + //Return correct psBits output for valid inputs with AND operator + { + out = psBitsOp(out, bs, "AND", bs2); + ok( out->bits[0] == 0, + "psBitsOp: return correct psBits output for valid inputs" + " with AND operator."); + } + //Return correct psBits output for valid inputs with OR operator + { + out = psBitsOp(out, bs, "OR", bs2); + ok( out->bits[0] == 6, + "psBitsOp: return correct psBits output for valid inputs" + " with OR operator."); + } + //Return correct psBits output for valid inputs with XOR operator + psBitsSet(bs2, 1); // 0000 0110 == 6 + { + out = psBitsOp(out, bs, "XOR", bs2); + ok( out->bits[0] == 4, + "psBitsOp: return correct psBits output for valid inputs" + " with XOR operator."); + } + //Return correct psBits output for valid inputs with NOT operator + { + psFree(out); + out = psBitsAlloc(0); + psBitsSet(bs, 2); // 0000 0110 == 4 + psBitsSet(bs, 3); // 0000 1110 == 12 + psBitsSet(bs, 4); // 0001 1110 == 28 + psBitsSet(bs, 5); // 0011 1110 == 60 + psBitsSet(bs, 6); // 0111 1110 == 124 + psBitsSet(bs, 7); // 1111 1110 == 252 + out = psBitsOp(out, bs, "NOT", bs2); + ok( out->bits[0] == 1, + "psBitsOp: return correct psBits output for valid inputs" + " with NOT operator."); + } + + //psBitsToString Tests + //Return NULL for NULL Bits input + psString bitStr = NULL; + { + bitStr = psBitsToString(noBits); + ok( bitStr == NULL, + "psBitsToString: return NULL for NULL Bits input."); + } + //Return correct string for valid Bits input + { + psFree(bs); + bs = psBitsAlloc(8); + psBitsSet(bs, 2); // 0000 0100 == 4 + bitStr = psBitsToString(bs); + ok( !strncmp(bitStr, "00000100", 10), + "psBitsToString: return correct string for valid Bits input (%s).", bitStr); + } + + psFree(bitStr); + psFree(out); + psFree(bs); + psFree(bs2); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } +}