Ignore:
Timestamp:
Jul 24, 2009, 8:48:27 AM (11 years ago)
Author:
Sam Hocevar
Message:

Add explanatory comments to the dirty rectangle unit tests.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcaca/trunk/tests/dirty.cpp

    r3557 r3567  
    4242    {
    4343        caca_canvas_t *cv;
    44         int i, dx, dy, dw, dh;
    45 
    46         /* Check that the dirty rectangle contains the whole canvas
    47          * upon creation. */
    48         cv = caca_create_canvas(WIDTH, HEIGHT);
    49         i = caca_get_dirty_rect_count(cv);
    50         CPPUNIT_ASSERT_EQUAL(i, 1);
    51 
    52         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    53         CPPUNIT_ASSERT_EQUAL(dx, 0);
    54         CPPUNIT_ASSERT_EQUAL(dy, 0);
    55         CPPUNIT_ASSERT_EQUAL(dw, caca_get_canvas_width(cv));
    56         CPPUNIT_ASSERT_EQUAL(dh, caca_get_canvas_height(cv));
     44        int dx, dy, dw, dh;
     45
     46        /* Check that we only have one dirty rectangle upon creation. */
     47        cv = caca_create_canvas(WIDTH, HEIGHT);
     48        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     49
     50        /* Check that our only rectangle contains the whole canvas. */
     51        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     52        CPPUNIT_ASSERT_EQUAL(0, dx);
     53        CPPUNIT_ASSERT_EQUAL(0, dy);
     54        CPPUNIT_ASSERT_EQUAL(WIDTH, dw);
     55        CPPUNIT_ASSERT_EQUAL(HEIGHT, dh);
    5756
    5857        /* Invalidate the dirty rectangle and check that it stays so. */
    5958        caca_clear_dirty_rect_list(cv);
    60         i = caca_get_dirty_rect_count(cv);
    61         CPPUNIT_ASSERT_EQUAL(i, 0);
     59        CPPUNIT_ASSERT_EQUAL(0, caca_get_dirty_rect_count(cv));
    6260
    6361        caca_free_canvas(cv);
    … …  
    6765    {
    6866        caca_canvas_t *cv;
    69         int i, dx, dy, dw, dh;
    70 
    71         cv = caca_create_canvas(WIDTH, HEIGHT);
    72 
    73         caca_clear_dirty_rect_list(cv);
    74         caca_put_char(cv, 7, 3, 'x');
    75         i = caca_get_dirty_rect_count(cv);
    76         CPPUNIT_ASSERT_EQUAL(i, 1);
    77         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    78         CPPUNIT_ASSERT_EQUAL(dx, 7);
    79         CPPUNIT_ASSERT_EQUAL(dy, 3);
    80         CPPUNIT_ASSERT_EQUAL(dw, 1);
    81         CPPUNIT_ASSERT_EQUAL(dh, 1);
    82 
    83         caca_clear_canvas(cv);
    84         caca_clear_dirty_rect_list(cv);
    85         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    86         i = caca_get_dirty_rect_count(cv);
    87         CPPUNIT_ASSERT_EQUAL(i, 1);
    88         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    89         CPPUNIT_ASSERT_EQUAL(dx, 7);
    90         CPPUNIT_ASSERT_EQUAL(dy, 3);
    91         CPPUNIT_ASSERT_EQUAL(dw, 2);
    92         CPPUNIT_ASSERT_EQUAL(dh, 1);
    93 
    94         caca_clear_canvas(cv);
    95         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    96         caca_clear_dirty_rect_list(cv);
    97         caca_put_char(cv, 7, 3, 'x');
    98         i = caca_get_dirty_rect_count(cv);
    99         CPPUNIT_ASSERT_EQUAL(i, 1);
    100         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    101         CPPUNIT_ASSERT_EQUAL(dx, 7);
    102         CPPUNIT_ASSERT_EQUAL(dy, 3);
    103         CPPUNIT_ASSERT_EQUAL(dw, 2);
    104         CPPUNIT_ASSERT_EQUAL(dh, 1);
    105 
     67        int dx, dy, dw, dh;
     68
     69        cv = caca_create_canvas(WIDTH, HEIGHT);
     70
     71        /* Check that one character creates a 1x1 dirty rect. */
     72        caca_clear_dirty_rect_list(cv);
     73        caca_put_char(cv, 7, 3, 'x');
     74
     75        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     76        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     77        CPPUNIT_ASSERT_EQUAL(7, dx);
     78        CPPUNIT_ASSERT_EQUAL(3, dy);
     79        CPPUNIT_ASSERT_EQUAL(1, dw);
     80        CPPUNIT_ASSERT_EQUAL(1, dh);
     81
     82        /* Check that a fullwidth character creates a 2x1 dirty rect. */
     83        caca_clear_canvas(cv);
     84        caca_clear_dirty_rect_list(cv);
     85        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
     86
     87        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     88        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     89        CPPUNIT_ASSERT_EQUAL(7, dx);
     90        CPPUNIT_ASSERT_EQUAL(3, dy);
     91        CPPUNIT_ASSERT_EQUAL(2, dw);
     92        CPPUNIT_ASSERT_EQUAL(1, dh);
     93
     94        /* Check that a character over a fullwidth character creates a
     95         * 2x1 dirty rect because of clobbering on the left side. */
     96        caca_clear_canvas(cv);
     97        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
     98        caca_clear_dirty_rect_list(cv);
     99        caca_put_char(cv, 7, 3, 'x');
     100
     101        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     102        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     103        CPPUNIT_ASSERT_EQUAL(7, dx);
     104        CPPUNIT_ASSERT_EQUAL(3, dy);
     105        CPPUNIT_ASSERT_EQUAL(2, dw);
     106        CPPUNIT_ASSERT_EQUAL(1, dh);
     107
     108        /* Check that a character over a fullwidth character creates a
     109         * 2x1 dirty rect because of clobbering on the right side. */
    106110        caca_clear_canvas(cv);
    107111        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    108112        caca_clear_dirty_rect_list(cv);
    109113        caca_put_char(cv, 8, 3, 'x');
    110         i = caca_get_dirty_rect_count(cv);
    111         CPPUNIT_ASSERT_EQUAL(i, 1);
    112         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    113         CPPUNIT_ASSERT_EQUAL(dx, 7);
    114         CPPUNIT_ASSERT_EQUAL(dy, 3);
    115         CPPUNIT_ASSERT_EQUAL(dw, 2);
    116         CPPUNIT_ASSERT_EQUAL(dh, 1);
    117 
     114
     115        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     116        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     117        CPPUNIT_ASSERT_EQUAL(7, dx);
     118        CPPUNIT_ASSERT_EQUAL(3, dy);
     119        CPPUNIT_ASSERT_EQUAL(2, dw);
     120        CPPUNIT_ASSERT_EQUAL(1, dh);
     121
     122        /* Check that a fullwidth character over a fullwidth character creates
     123         * a 3x1 dirty rect because of clobbering on the left side. */
    118124        caca_clear_canvas(cv);
    119125        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    120126        caca_clear_dirty_rect_list(cv);
    121127        caca_put_char(cv, 6, 3, 0x2f06 /* ⼆ */);
    122         i = caca_get_dirty_rect_count(cv);
    123         CPPUNIT_ASSERT_EQUAL(i, 1);
    124         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    125         CPPUNIT_ASSERT_EQUAL(dx, 6);
    126         CPPUNIT_ASSERT_EQUAL(dy, 3);
    127         CPPUNIT_ASSERT_EQUAL(dw, 3);
    128         CPPUNIT_ASSERT_EQUAL(dh, 1);
    129 
     128
     129        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     130        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     131        CPPUNIT_ASSERT_EQUAL(6, dx);
     132        CPPUNIT_ASSERT_EQUAL(3, dy);
     133        CPPUNIT_ASSERT_EQUAL(3, dw);
     134        CPPUNIT_ASSERT_EQUAL(1, dh);
     135
     136        /* Check that a fullwidth character over a fullwidth character creates
     137         * a 3x1 dirty rect because of clobbering on the right side. */
    130138        caca_clear_canvas(cv);
    131139        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    132140        caca_clear_dirty_rect_list(cv);
    133141        caca_put_char(cv, 8, 3, 0x2f06 /* ⼆ */);
    134         i = caca_get_dirty_rect_count(cv);
    135         CPPUNIT_ASSERT_EQUAL(i, 1);
    136         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    137         CPPUNIT_ASSERT_EQUAL(dx, 7);
    138         CPPUNIT_ASSERT_EQUAL(dy, 3);
    139         CPPUNIT_ASSERT_EQUAL(dw, 3);
    140         CPPUNIT_ASSERT_EQUAL(dh, 1);
     142
     143        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     144        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     145        CPPUNIT_ASSERT_EQUAL(7, dx);
     146        CPPUNIT_ASSERT_EQUAL(3, dy);
     147        CPPUNIT_ASSERT_EQUAL(3, dw);
     148        CPPUNIT_ASSERT_EQUAL(1, dh);
    141149    }
    142150
    … …  
    144152    {
    145153        caca_canvas_t *cv;
    146         int i;
    147 
    148         cv = caca_create_canvas(WIDTH, HEIGHT);
    149 
    150         /* Check that pasting the same character does not cause
     154
     155        cv = caca_create_canvas(WIDTH, HEIGHT);
     156
     157        /* Check that pasting the same character does not cause a dirty
     158         * rectangle to be created. */
     159        caca_put_char(cv, 7, 3, 'x');
     160        caca_clear_dirty_rect_list(cv);
     161        caca_put_char(cv, 7, 3, 'x');
     162
     163        CPPUNIT_ASSERT_EQUAL(0, caca_get_dirty_rect_count(cv));
     164
     165        /* Check that pasting the same fullwidth character does not cause
    151166         * a dirty rectangle to be created. */
    152         caca_put_char(cv, 7, 3, 'x');
    153         caca_clear_dirty_rect_list(cv);
    154         caca_put_char(cv, 7, 3, 'x');
    155         i = caca_get_dirty_rect_count(cv);
    156         CPPUNIT_ASSERT_EQUAL(i, 0);
    157 
    158         caca_clear_canvas(cv);
    159         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    160         caca_clear_dirty_rect_list(cv);
    161         caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
    162         i = caca_get_dirty_rect_count(cv);
    163         CPPUNIT_ASSERT_EQUAL(i, 0);
     167        caca_clear_canvas(cv);
     168        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
     169        caca_clear_dirty_rect_list(cv);
     170        caca_put_char(cv, 7, 3, 0x2f06 /* ⼆ */);
     171
     172        CPPUNIT_ASSERT_EQUAL(0, caca_get_dirty_rect_count(cv));
    164173    }
    165174
    … …  
    167176    {
    168177        caca_canvas_t *cv;
    169         int i, dx, dy, dw, dh;
    170 
    171         cv = caca_create_canvas(WIDTH, HEIGHT);
    172         caca_clear_dirty_rect_list(cv);
    173 
     178        int dx, dy, dw, dh;
     179
     180        cv = caca_create_canvas(WIDTH, HEIGHT);
     181        caca_clear_dirty_rect_list(cv);
     182
     183        /* Check that a filled box creates one dirty rectangle of the same
     184         * size. */
    174185        caca_fill_box(cv, 7, 3, 14, 9, 'x');
    175         i = caca_get_dirty_rect_count(cv);
    176         CPPUNIT_ASSERT_EQUAL(i, 1);
    177         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    178         CPPUNIT_ASSERT_EQUAL(dx, 7);
    179         CPPUNIT_ASSERT_EQUAL(dy, 3);
    180         CPPUNIT_ASSERT_EQUAL(dw, 14);
    181         CPPUNIT_ASSERT_EQUAL(dh, 9);
    182 
     186
     187        CPPUNIT_ASSERT_EQUAL(1, caca_get_dirty_rect_count(cv));
     188        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     189        CPPUNIT_ASSERT_EQUAL(7, dx);
     190        CPPUNIT_ASSERT_EQUAL(3, dy);
     191        CPPUNIT_ASSERT_EQUAL(14, dw);
     192        CPPUNIT_ASSERT_EQUAL(9, dh);
     193
     194        /* Check that the same filled box does not create a new dirty
     195         * rectangle. */
    183196        caca_clear_dirty_rect_list(cv);
    184197        caca_fill_box(cv, 7, 3, 14, 9, 'x');
    185         i = caca_get_dirty_rect_count(cv);
    186         CPPUNIT_ASSERT_EQUAL(i, 0);
     198
     199        CPPUNIT_ASSERT_EQUAL(0, caca_get_dirty_rect_count(cv));
    187200    }
    188201
    … …  
    199212        /* Check that blitting a canvas make a dirty rectangle
    200213         * only for modified lines */
     214        /* FIXME: check this test's validity */
    201215
    202216        caca_blit(cv, 1, 1, cv2, NULL);
    203217        i = caca_get_dirty_rect_count(cv);
    204         CPPUNIT_ASSERT_EQUAL(i, 1);
    205         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    206 
    207         CPPUNIT_ASSERT(dx == 1);
    208         CPPUNIT_ASSERT(dy == 1);
    209         CPPUNIT_ASSERT(dw >= 2);
    210         CPPUNIT_ASSERT(dh == 1);
     218        CPPUNIT_ASSERT_EQUAL(1, i);
     219        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     220
     221        CPPUNIT_ASSERT(1 == dx);
     222        CPPUNIT_ASSERT(1 == dy);
     223        CPPUNIT_ASSERT(2 <= dw);
     224        CPPUNIT_ASSERT(1 == dh);
    211225
    212226        caca_clear_canvas(cv);
    … …  
    215229        /* Check that blitting a canvas make a dirty rectangle
    216230         * only for modified chars when we have a mask */
     231        /* FIXME: check this test's validity */
    217232
    218233        caca_blit(cv, 1, 1, cv2, cv2);
    219234        i = caca_get_dirty_rect_count(cv);
    220         CPPUNIT_ASSERT_EQUAL(i, 1);
    221         caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
    222 
    223         CPPUNIT_ASSERT(dx == 1);
    224         CPPUNIT_ASSERT(dy == 1);
    225         CPPUNIT_ASSERT(dw == 2);
    226         CPPUNIT_ASSERT(dh == 1);
     235        CPPUNIT_ASSERT_EQUAL(1, i);
     236        caca_get_dirty_rect(cv, 0, &dx, &dy, &dw, &dh);
     237
     238        CPPUNIT_ASSERT(1 == dx);
     239        CPPUNIT_ASSERT(1 == dy);
     240        CPPUNIT_ASSERT(2 == dw);
     241        CPPUNIT_ASSERT(1 == dh);
     242
     243        CPPUNIT_ASSERT(' ' == caca_get_char(cv, 0, 0));
     244
    227245    }
    228246
    229247private:
    230     static int const WIDTH = 80, HEIGHT = 50;
     248    static int const WIDTH, HEIGHT;
    231249};
    232250
     251int const DirtyTest::WIDTH = 80;
     252int const DirtyTest::HEIGHT = 50;
     253
    233254CPPUNIT_TEST_SUITE_REGISTRATION(DirtyTest);
    234255
Note: See TracChangeset for help on using the changeset viewer.