decl.c

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define TMin INT_MIN
#define TMax INT_MAX

#include "btest.h"
#include "bits.h"

test_rec test_set[] = {
    {"absVal",
     (func_t) absVal,
     (func_t) test_absVal,
     1,
     "! ~ & ^ | + << >>",
     10,
     4,
     {{-TMax, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"addOK",
     (func_t) addOK,
     (func_t) test_addOK,
     2,
     "! ~ & ^ | + << >>",
     20,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"allEvenBits",
     (func_t) allEvenBits,
     (func_t) test_allEvenBits,
     1,
     "! ~ & ^ | + << >>",
     12,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"allOddBits",
     (func_t) allOddBits,
     (func_t) test_allOddBits,
     1,
     "! ~ & ^ | + << >>",
     12,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"anyEvenBit",
     (func_t) anyEvenBit,
     (func_t) test_anyEvenBit,
     1,
     "! ~ & ^ | + << >>",
     12,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"anyOddBit",
     (func_t) anyOddBit,
     (func_t) test_anyOddBit,
     1,
     "! ~ & ^ | + << >>",
     12,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bang",
     (func_t) bang,
     (func_t) test_bang,
     1,
     "~ & ^ | + << >>",
     12,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitAnd",
     (func_t) bitAnd,
     (func_t) test_bitAnd,
     2,
     "| ~",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitCount",
     (func_t) bitCount,
     (func_t) test_bitCount,
     1,
     "! ~ & ^ | + << >>",
     40,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitMask",
     (func_t) bitMask,
     (func_t) test_bitMask,
     2,
     "! ~ & ^ | + << >>",
     16,
     3,
     {{0, 31}, {0, 31}, {TMin, TMax}}},

    {"bitMatch",
     (func_t) bitMatch,
     (func_t) test_bitMatch,
     2,
     "& | ~",
     14,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitNor",
     (func_t) bitNor,
     (func_t) test_bitNor,
     2,
     "& ~",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitOr",
     (func_t) bitOr,
     (func_t) test_bitOr,
     2,
     "& ~",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitParity",
     (func_t) bitParity,
     (func_t) test_bitParity,
     1,
     "! ~ & ^ | + << >>",
     20,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitReverse",
     (func_t) bitReverse,
     (func_t) test_bitReverse,
     1,
     "! ~ & ^ | + << >>",
     45,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"bitXor",
     (func_t) bitXor,
     (func_t) test_bitXor,
     2,
     "& ~",
     14,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"byteSwap",
     (func_t) byteSwap,
     (func_t) test_byteSwap,
     3,
     "! ~ & ^ | + << >>",
     25,
     2,
     {{TMin, TMax}, {0, 3}, {0, 3}}},

    {"conditional",
     (func_t) conditional,
     (func_t) test_conditional,
     3,
     "! ~ & ^ | << >>",
     16,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"countLeadingZero",
     (func_t) countLeadingZero,
     (func_t) test_countLeadingZero,
     1,
     "! ~ & ^ | + << >>",
     50,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"copyLSB",
     (func_t) copyLSB,
     (func_t) test_copyLSB,
     1,
     "! ~ & ^ | + << >>",
     5,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"distinctNegation",
     (func_t) distinctNegation,
     (func_t) test_distinctNegation,
     1,
     "! ~ & ^ | +",
     5,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"dividePower2",
     (func_t) dividePower2,
     (func_t) test_dividePower2,
     2,
     "! ~ & ^ | + << >>",
     15,
     2,
     {{TMin, TMax}, {0, 30}, {TMin, TMax}}},

    {"evenBits",
     (func_t) evenBits,
     (func_t) test_evenBits,
     0,
     "! ~ & ^ | + << >>",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"ezThreeFourths",
     (func_t) ezThreeFourths,
     (func_t) test_ezThreeFourths,
     1,
     "! ~ & ^ | + << >>",
     12,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"fitsBits",
     (func_t) fitsBits,
     (func_t) test_fitsBits,
     2,
     "! ~ & ^ | + << >>",
     15,
     2,
     {{TMin, TMax}, {1, 32}, {TMin, TMax}}},

    {"fitsShort",
     (func_t) fitsShort,
     (func_t) test_fitsShort,
     1,
     "! ~ & ^ | + << >>",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"floatAbsVal",
     (func_t) floatAbsVal,
     (func_t) test_floatAbsVal,
     1,
     "$",
     10,
     2,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatFloat2Int",
     (func_t) floatFloat2Int,
     (func_t) test_floatFloat2Int,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatInt2Float",
     (func_t) floatInt2Float,
     (func_t) test_floatInt2Float,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatIsEqual",
     (func_t) floatIsEqual,
     (func_t) test_floatIsEqual,
     2,
     "$",
     25,
     2,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatIsLess",
     (func_t) floatIsLess,
     (func_t) test_floatIsLess,
     2,
     "$",
     30,
     3,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatNegate",
     (func_t) floatNegate,
     (func_t) test_floatNegate,
     1,
     "$",
     10,
     2,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatPower2",
     (func_t) floatPower2,
     (func_t) test_floatPower2,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatScale1d2",
     (func_t) floatScale1d2,
     (func_t) test_floatScale1d2,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatScale2",
     (func_t) floatScale2,
     (func_t) test_floatScale2,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatScale64",
     (func_t) floatScale64,
     (func_t) test_floatScale64,
     1,
     "$",
     35,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"floatUnsigned2Float",
     (func_t) floatUnsigned2Float,
     (func_t) test_floatUnsigned2Float,
     1,
     "$",
     30,
     4,
     {{1, 1}, {1, 1}, {1, 1}}},

    {"getByte",
     (func_t) getByte,
     (func_t) test_getByte,
     2,
     "! ~ & ^ | + << >>",
     6,
     2,
     {{TMin, TMax}, {0, 3}, {TMin, TMax}}},

    {"greatestBitPos",
     (func_t) greatestBitPos,
     (func_t) test_greatestBitPos,
     1,
     "! ~ & ^ | + << >>",
     70,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"howManyBits",
     (func_t) howManyBits,
     (func_t) test_howManyBits,
     1,
     "! ~ & ^ | + << >>",
     90,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"implication",
     (func_t) implication,
     (func_t) test_implication,
     2,
     "! ~ ^ |",
     5,
     2,
     {{0, 1}, {0, 1}, {TMin, TMax}}},

    {"intLog2",
     (func_t) intLog2,
     (func_t) test_intLog2,
     1,
     "! ~ & ^ | + << >>",
     90,
     4,
     {{1, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isAsciiDigit",
     (func_t) isAsciiDigit,
     (func_t) test_isAsciiDigit,
     1,
     "! ~ & ^ | + << >>",
     15,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isEqual",
     (func_t) isEqual,
     (func_t) test_isEqual,
     2,
     "! ~ & ^ | + << >>",
     5,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isGreater",
     (func_t) isGreater,
     (func_t) test_isGreater,
     2,
     "! ~ & ^ | + << >>",
     24,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isLess",
     (func_t) isLess,
     (func_t) test_isLess,
     2,
     "! ~ & ^ | + << >>",
     24,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isLessOrEqual",
     (func_t) isLessOrEqual,
     (func_t) test_isLessOrEqual,
     2,
     "! ~ & ^ | + << >>",
     24,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isNegative",
     (func_t) isNegative,
     (func_t) test_isNegative,
     1,
     "! ~ & ^ | + << >>",
     6,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isNonNegative",
     (func_t) isNonNegative,
     (func_t) test_isNonNegative,
     1,
     "! ~ & ^ | + << >>",
     6,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isNonZero",
     (func_t) isNonZero,
     (func_t) test_isNonZero,
     1,
     "~ & ^ | + << >>",
     10,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isNotEqual",
     (func_t) isNotEqual,
     (func_t) test_isNotEqual,
     2,
     "! ~ & ^ | + << >>",
     6,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isPallindrome",
     (func_t) isPallindrome,
     (func_t) test_isPallindrome,
     1,
     "! ~ & ^ | + << >>",
     40,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isPositive",
     (func_t) isPositive,
     (func_t) test_isPositive,
     1,
     "! ~ & ^ | + << >>",
     8,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isPower2",
     (func_t) isPower2,
     (func_t) test_isPower2,
     1,
     "! ~ & ^ | + << >>",
     20,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isTmax",
     (func_t) isTmax,
     (func_t) test_isTmax,
     1,
     "! ~ & ^ | +",
     10,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isTmin",
     (func_t) isTmin,
     (func_t) test_isTmin,
     1,
     "! ~ & ^ | +",
     10,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"isZero",
     (func_t) isZero,
     (func_t) test_isZero,
     1,
     "! ~ & ^ | + << >>",
     2,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"leastBitPos",
     (func_t) leastBitPos,
     (func_t) test_leastBitPos,
     1,
     "! ~ & ^ | + << >>",
     6,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"leftBitCount",
     (func_t) leftBitCount,
     (func_t) test_leftBitCount,
     1,
     "! ~ & ^ | + << >>",
     40,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"logicalNeg",
     (func_t) logicalNeg,
     (func_t) test_logicalNeg,
     1,
     "~ & ^ | + << >>",
     12,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"logicalShift",
     (func_t) logicalShift,
     (func_t) test_logicalShift,
     2,
     "! ~ & ^ | + << >>",
     20,
     3,
     {{TMin, TMax}, {0, 31}, {TMin, TMax}}},

    {"maximumOfTwo",
     (func_t) maximumOfTwo,
     (func_t) test_maximumOfTwo,
     2,
     "! ~ & ^ | + << >>",
     20,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"minimumOfTwo",
     (func_t) minimumOfTwo,
     (func_t) test_minimumOfTwo,
     2,
     "! ~ & ^ | + << >>",
     20,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"minusOne",
     (func_t) minusOne,
     (func_t) test_minusOne,
     0,
     "! ~ & ^ | + << >>",
     2,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"multFiveEighths",
     (func_t) multFiveEighths,
     (func_t) test_multFiveEighths,
     1,
     "! ~ & ^ | + << >>",
     12,
     3,
     {{-(1 << 28) - 1, (1 << 28) - 1}, {TMin, TMax}, {TMin, TMax}}},

    {"negate",
     (func_t) negate,
     (func_t) test_negate,
     1,
     "! ~ & ^ | + << >>",
     5,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"oddBits",
     (func_t) oddBits,
     (func_t) test_oddBits,
     0,
     "! ~ & ^ | + << >>",
     8,
     2,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"remainderPower2",
     (func_t) remainderPower2,
     (func_t) test_remainderPower2,
     2,
     "! ~ & ^ | + << >>",
     20,
     3,
     {{TMin, TMax}, {0, 30}, {TMin, TMax}}},

    {"replaceByte",
     (func_t) replaceByte,
     (func_t) test_replaceByte,
     3,
     "! ~ & ^ | + << >>",
     10,
     3,
     {{TMin, TMax}, {0, 3}, {0, 255}}},

    {"rotateLeft",
     (func_t) rotateLeft,
     (func_t) test_rotateLeft,
     2,
     "! ~ & ^ | + << >>",
     25,
     3,
     {{TMin, TMax}, {0, 31}, {TMin, TMax}}},

    {"rotateRight",
     (func_t) rotateRight,
     (func_t) test_rotateRight,
     2,
     "! ~ & ^ | + << >>",
     25,
     3,
     {{TMin, TMax}, {0, 31}, {TMin, TMax}}},

    {"satAdd",
     (func_t) satAdd,
     (func_t) test_satAdd,
     2,
     "! ~ & ^ | + << >>",
     30,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"satMul2",
     (func_t) satMul2,
     (func_t) test_satMul2,
     1,
     "~ & ^ | + << >>",
     20,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"satMul3",
     (func_t) satMul3,
     (func_t) test_satMul3,
     1,
     "~ & ^ | + << >>",
     25,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"sign",
     (func_t) sign,
     (func_t) test_sign,
     1,
     "! ~ & ^ | + << >>",
     10,
     2,
     {{-TMax, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"signMag2TwosComp",
     (func_t) signMag2TwosComp,
     (func_t) test_signMag2TwosComp,
     1,
     "! ~ & ^ | + << >>",
     15,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"specialBits",
     (func_t) specialBits,
     (func_t) test_specialBits,
     0,
     "! ~ & ^ | + << >>",
     3,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"subtractionOK",
     (func_t) subtractionOK,
     (func_t) test_subtractionOK,
     2,
     "! ~ & ^ | + << >>",
     20,
     3,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"thirdBits",
     (func_t) thirdBits,
     (func_t) test_thirdBits,
     0,
     "! ~ & ^ | + << >>",
     8,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"tmax",
     (func_t) tmax,
     (func_t) test_tmax,
     0,
     "! ~ & ^ | + << >>",
     4,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"tmin",
     (func_t) tmin,
     (func_t) test_tmin,
     0,
     "! ~ & ^ | + << >>",
     4,
     1,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"trueFiveEighths",
     (func_t) trueFiveEighths,
     (func_t) test_trueFiveEighths,
     1,
     "! ~ & ^ | + << >>",
     25,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"trueThreeFourths",
     (func_t) trueThreeFourths,
     (func_t) test_trueThreeFourths,
     1,
     "! ~ & ^ | + << >>",
     20,
     4,
     {{TMin, TMax}, {TMin, TMax}, {TMin, TMax}}},

    {"twosComp2SignMag",
     (func_t) twosComp2SignMag,
     (func_t) test_twosComp2SignMag,
     1,
     "! ~ & ^ | + << >>",
     15,
     4,
     {{TMin + 1, TMax}, {TMin + 1, TMax}, {TMin + 1, TMax}}},

    {"upperBits",
     (func_t) upperBits,
     (func_t) test_upperBits,
     1,
     "! ~ & ^ | + << >>",
     10,
     1,
     {{0, 32}, {TMin, TMax}, {TMin, TMax}}},

    {"", NULL, NULL, 0, "", 0, 0, {{0, 0}, {0, 0}, {0, 0}}}};