/* vim: set expandtab ts=4 sw=4: */
/*
* You may redistribute this program and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#define NumberCompress_OLD_CODE
#include "switch/NumberCompress.h"
#include "switch/EncodingScheme.h"
#include "memory/MallocAllocator.h"
#include "util/Assert.h"
#include
#include
static void numberCompressions_generic(
uint32_t nInterfaces,
uint32_t (*bitsUsedForLabel)(const uint64_t label),
uint32_t (*bitsUsedForNumber)(const uint32_t number),
uint64_t (*getCompressed)(const uint32_t number, const uint32_t bitsUsed),
uint32_t (*getDecompressed)(const uint64_t label, const uint32_t bitsUsed),
struct EncodingScheme* (* defineScheme)(struct Allocator* alloc) )
{
uint8_t bitWidths[64] = { 0 };
for (uint32_t i = 0; i < nInterfaces; ++i) {
bitWidths[bitsUsedForNumber(i)] = 1;
}
for (uint32_t bits = 0; bits < 64; ++bits) {
if (!bitWidths[bits]) {
continue;
}
for (uint32_t i = 0; i < nInterfaces; ++i) {
/* only check for greater-or-equal bit widths */
if (bits < bitsUsedForNumber(i)) {
continue;
}
uint64_t label = getCompressed(i, bits);
if (1 == i) {
Assert_true(1 == label);
continue;
}
Assert_true(bits == bitsUsedForLabel(label));
Assert_true(i == getDecompressed(label, bits));
}
}
for (uint64_t label = 0; label < 0x10000u; ++label) {
uint32_t bits = bitsUsedForLabel(label);
Assert_true(1 == bitWidths[bits]);
if (1 == (label & Bits_maxBits64(bits))) {
//Assert_true(4 == bits);
Assert_true(1 == getDecompressed(label, bits));
} else {
uint32_t i = getDecompressed(label, bits);
Assert_true(i < nInterfaces);
}
}
struct Allocator* alloc = MallocAllocator_new(20000);
struct EncodingScheme* scheme = defineScheme(alloc);
for (uint32_t i = 0; i < nInterfaces; i++) {
for (int j = 0; j < scheme->count; j++) {
int bits = EncodingScheme_formSize(&scheme->forms[j]);
if ((int)bitsUsedForNumber(i) > bits) { continue; }
uint64_t label = getCompressed(i, bits);
for (int k = j; k < scheme->count; k++) {
uint64_t labelB = EncodingScheme_convertLabel(scheme, label, k);
if (1 == i && k != 0) {
Assert_true(1 == label);
Assert_true(EncodingScheme_convertLabel_INVALID == labelB);
continue;
}
int bitsB = bitsUsedForLabel(labelB);
Assert_true(bitsB == scheme->forms[k].prefixLen + scheme->forms[k].bitCount
|| (i == 1 && bitsB == 4));
//printf("%u == %u (%lu / %d)\n", i, getDecompressed(labelB, bitsB), labelB, bitsB);
Assert_true(i == getDecompressed(labelB, bitsB));
uint64_t labelC = EncodingScheme_convertLabel(scheme, labelB, j);
Assert_true(labelC == label);
}
}
}
Allocator_free(alloc);
}
#define TEST(impl) \
numberCompressions_generic( \
GLUE(impl, INTERFACES), \
GLUE(impl, bitsUsedForLabel), \
GLUE(impl, bitsUsedForNumber), \
GLUE(impl, getCompressed), \
GLUE(impl, getDecompressed), \
GLUE(impl, defineScheme) \
)
#define GLUE(a,b) GLUE2(a,b)
#define GLUE2(a,b) NumberCompress_ ## a ## _ ## b
int main()
{
TEST(f4);
TEST(f8);
TEST(v3x5x8);
TEST(v4x8);
return 0;
}