Ignore:
Timestamp:
07/24/09 08:48:27 (4 years ago)
Author:
sam
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.