int
main(int argc, char *argv[])
{
    gtk_init (&argc, &argv);
    test_only_scale_op_on_new_identical_pixbuf ();
    test_cache_is_used_on_equal_opts ();
    test_contains_even_if_cache_to_small ();
    test_scroll_needed_if_rect_size_not_equal ();
    test_default_draw_options ();
    test_invalidate ();
    printf ("6 tests passed.\n");
}
Пример #2
0
/** test shrinkExpand
 */
static
void test_shrinkExpand(uint32_t dim)
{
    uint32_t intSize = bits2intsize(dim);
    uint32_t tableSize = intSize*32;
    cindex_t srcTable[tableSize];
    cindex_t dstTable[tableSize];
    cindex_t checkTable[tableSize];
    uint32_t bitString1[intSize];
    uint32_t bitString2[intSize];
    raw_t *dbm1 = allocDBM(dim);
    raw_t *dbm2 = allocDBM(dim);
    uint32_t k;

    printf("Testing shrinkExpand(%u)\n", dim);

    for(k = 0; k < 10000; ++k)
    {
        cindex_t dim1 = rand()%dim + 1;
        cindex_t dim2 = rand()%dim + 1;
        cindex_t i,j;

        PROGRESS();

        test_invalidate(srcTable, tableSize);
        test_invalidate(dstTable, tableSize);
        test_invalidate(checkTable, tableSize);

        /* generate 2 bit tables */
        debug_generateBits(bitString1, intSize,
                           dim1, ONE);
        debug_generateBits(bitString2, intSize,
                           dim2, ONE);
        assert(base_countBitsN(bitString1, intSize) == dim1);
        assert(base_countBitsN(bitString2, intSize) == dim2);
        
        /* respect precondition
         */
        if (!base_areBitsEqual(bitString1, bitString2, intSize))
        {
            /* generate source DBM */
            dbm_generate(dbm1, dim1, 50000);
            
            /* unpack */
            base_bits2indexTable(bitString1, intSize, srcTable);
            base_bits2indexTable(bitString2, intSize, checkTable);

            /* shrinkExpand */
            assert(dim2 ==
                   dbm_shrinkExpand(dbm1, dbm2,
                                    dim1,
                                    bitString1,
                                    bitString2,
                                    intSize,
                                    dstTable));

            assert(dbm_isValid(dbm2, dim2));

            /* check table */
            assert(base_areEqual(dstTable, checkTable, intsizeof(cindex_t[dim])));
            
            for(i = 0; i < dim; ++i)
            {
                for(j = 0; j < dim; ++j)
                {
                    /* valid index condition == ~table[i]
                     * because of the invalidate value
                     */
                    if ((~dstTable[i]) && (~dstTable[j]))
                    {
                        if ((~srcTable[i]) && (~srcTable[j]))
                        {
                            assert(DBM1(srcTable[i], srcTable[j]) ==
                                   DBM2(dstTable[i], dstTable[j]));
                        }
                        else
                        {
                            if (i == 0 || i == j)
                            {
                                assert(DBM2(dstTable[i], dstTable[j]) ==
                                       dbm_LE_ZERO); /* new clock */
                            }
                            else
                            {
                                assert(DBM2(dstTable[i], dstTable[j]) ==
                                       (j == 0 ? dbm_LS_INFINITY :
                                        DBM2(dstTable[i], dstTable[0])));
                            }
                        }
                    }
                }
            }
        }

        /* print something to check
         
        if (k == 0 && dim1 < 10 && dim2 < 10)
        {
            test_debugPrint(dbm1, dim1,
                            dbm2, dim2,
                            srcTable, dstTable, tableSize,
                            0, 0);
        }
        */
    }

    free(dbm2);
    free(dbm1);
}