LCOV - code coverage report
Current view: top level - src/tests - common.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 87 87 100.0 %
Date: 2025-03-29 09:04:10 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 48 88 54.5 %

           Branch data     Line data    Source code
       1                 :            : #include "utils.h"
       2                 :            : 
       3                 :            : static int irand()
       4                 :            : {
       5                 :          1 :     return rand() - RAND_MAX / 2;
       6                 :            : }
       7                 :            : 
       8                 :          1 : int main()
       9                 :            : {
      10                 :          1 :     pl_log log = pl_test_logger();
      11                 :          1 :     pl_log_update(log, NULL);
      12                 :          1 :     pl_log_destroy(&log);
      13                 :            : 
      14                 :            :     // Test some misc helper functions
      15                 :          1 :     pl_rect2d rc2 = {
      16                 :            :         irand(), irand(),
      17                 :            :         irand(), irand(),
      18                 :            :     };
      19                 :            : 
      20                 :          1 :     pl_rect3d rc3 = {
      21                 :            :         irand(), irand(), irand(),
      22                 :            :         irand(), irand(), irand(),
      23                 :            :     };
      24                 :            : 
      25                 :          1 :     pl_rect2d_normalize(&rc2);
      26         [ -  + ]:          1 :     REQUIRE_CMP(rc2.x1, >=, rc2.x0, "d");
      27         [ -  + ]:          1 :     REQUIRE_CMP(rc2.y1, >=, rc2.y0, "d");
      28                 :            : 
      29                 :          1 :     pl_rect3d_normalize(&rc3);
      30         [ -  + ]:          1 :     REQUIRE_CMP(rc3.x1, >=, rc3.x0, "d");
      31         [ -  + ]:          1 :     REQUIRE_CMP(rc3.y1, >=, rc3.y0, "d");
      32         [ -  + ]:          1 :     REQUIRE_CMP(rc3.z1, >=, rc3.z0, "d");
      33                 :            : 
      34                 :          4 :     pl_rect2df rc2f = {
      35                 :          1 :         RANDOM, RANDOM,
      36                 :          1 :         RANDOM, RANDOM,
      37                 :            :     };
      38                 :            : 
      39                 :          6 :     pl_rect3df rc3f = {
      40                 :          1 :         RANDOM, RANDOM, RANDOM,
      41                 :          1 :         RANDOM, RANDOM, RANDOM,
      42                 :            :     };
      43                 :            : 
      44                 :          1 :     pl_rect2df_normalize(&rc2f);
      45         [ -  + ]:          1 :     REQUIRE_CMP(rc2f.x1, >=, rc2f.x0, "f");
      46         [ -  + ]:          1 :     REQUIRE_CMP(rc2f.y1, >=, rc2f.y0, "f");
      47                 :            : 
      48                 :          1 :     pl_rect3df_normalize(&rc3f);
      49         [ -  + ]:          1 :     REQUIRE_CMP(rc3f.x1, >=, rc3f.x0, "f");
      50         [ -  + ]:          1 :     REQUIRE_CMP(rc3f.y1, >=, rc3f.y0, "f");
      51         [ -  + ]:          1 :     REQUIRE_CMP(rc3f.z1, >=, rc3f.z0, "f");
      52                 :            : 
      53                 :          1 :     pl_rect2d rc2r = pl_rect2df_round(&rc2f);
      54                 :          1 :     pl_rect3d rc3r = pl_rect3df_round(&rc3f);
      55                 :            : 
      56         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc2r.x0 - rc2f.x0), <=, 0.5, "f");
      57         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc2r.x1 - rc2f.x1), <=, 0.5, "f");
      58         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc2r.y0 - rc2f.y0), <=, 0.5, "f");
      59         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc2r.y1 - rc2f.y1), <=, 0.5, "f");
      60                 :            : 
      61         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.x0 - rc3f.x0), <=, 0.5, "f");
      62         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.x1 - rc3f.x1), <=, 0.5, "f");
      63         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.y0 - rc3f.y0), <=, 0.5, "f");
      64         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.y1 - rc3f.y1), <=, 0.5, "f");
      65         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.z0 - rc3f.z0), <=, 0.5, "f");
      66         [ -  + ]:          1 :     REQUIRE_CMP(fabs(rc3r.z1 - rc3f.z1), <=, 0.5, "f");
      67                 :            : 
      68                 :         12 :     pl_transform3x3 tr = {
      69                 :            :         .mat = {{
      70                 :          1 :             { RANDOM, RANDOM, RANDOM },
      71                 :          1 :             { RANDOM, RANDOM, RANDOM },
      72                 :          1 :             { RANDOM, RANDOM, RANDOM },
      73                 :            :         }},
      74                 :          1 :         .c = { RANDOM, RANDOM, RANDOM },
      75                 :            :     };
      76                 :            : 
      77                 :          1 :     pl_transform3x3 tr2 = tr;
      78                 :          1 :     float scale = 1.0 + RANDOM;
      79                 :          1 :     pl_transform3x3_scale(&tr2, scale);
      80                 :          1 :     pl_transform3x3_invert(&tr2);
      81                 :          1 :     pl_transform3x3_invert(&tr2);
      82                 :          1 :     pl_transform3x3_scale(&tr2, 1.0 / scale);
      83                 :            : 
      84         [ +  + ]:          4 :     for (int i = 0; i < 3; i++) {
      85         [ +  + ]:         12 :         for (int j = 0; j < 3; j++) {
      86                 :         18 :             printf("%f %f\n", tr.mat.m[i][j], tr2.mat.m[i][j]);
      87         [ -  + ]:          9 :             REQUIRE_FEQ(tr.mat.m[i][j], tr2.mat.m[i][j], 1e-4);
      88                 :            :         }
      89         [ -  + ]:          3 :         REQUIRE_FEQ(tr.c[i], tr2.c[i], 1e-4);
      90                 :            :     }
      91                 :            : 
      92                 :            :     // Test aspect ratio code
      93                 :          1 :     const pl_rect2df rc1080p = {0, 0, 1920, 1080};
      94                 :          1 :     const pl_rect2df rc43 = {0, 0, 1024, 768};
      95                 :            :     pl_rect2df rc;
      96                 :            : 
      97         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_aspect(&rc1080p), 16.0/9.0, 1e-8);
      98         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_aspect(&rc43), 4.0/3.0, 1e-8);
      99                 :            : 
     100                 :            : #define pl_rect2df_midx(rc) (((rc).x0 + (rc).x1) / 2.0)
     101                 :            : #define pl_rect2df_midy(rc) (((rc).y0 + (rc).y1) / 2.0)
     102                 :            : 
     103         [ +  + ]:          8 :     for (float aspect = 0.2; aspect < 3.0; aspect += 0.4) {
     104         [ +  + ]:         28 :         for (float scan = 0.0; scan <= 1.0; scan += 0.5) {
     105                 :         21 :             rc = rc1080p;
     106                 :         21 :             pl_rect2df_aspect_set(&rc, aspect, scan);
     107                 :         21 :             printf("aspect %.2f, panscan %.1f: {%f %f} -> {%f %f}\n",
     108                 :         21 :                    aspect, scan, rc.x0, rc.y0, rc.x1, rc.y1);
     109         [ -  + ]:         21 :             REQUIRE_FEQ(pl_rect2df_aspect(&rc), aspect, 1e-6);
     110         [ -  + ]:         21 :             REQUIRE_FEQ(pl_rect2df_midx(rc), pl_rect2df_midx(rc1080p), 1e-6);
     111         [ -  + ]:         21 :             REQUIRE_FEQ(pl_rect2df_midy(rc), pl_rect2df_midy(rc1080p), 1e-6);
     112                 :            :         }
     113                 :            :     }
     114                 :            : 
     115                 :          1 :     rc = rc1080p;
     116                 :          1 :     pl_rect2df_aspect_fit(&rc, &rc43, 0.0);
     117         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_aspect(&rc), pl_rect2df_aspect(&rc43), 1e-6);
     118         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_midx(rc), pl_rect2df_midx(rc1080p), 1e-6);
     119         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_midy(rc), pl_rect2df_midy(rc1080p), 1e-6);
     120         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect_w(rc), pl_rect_w(rc43), 1e-6);
     121         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect_h(rc), pl_rect_h(rc43), 1e-6);
     122                 :            : 
     123                 :          1 :     rc = rc43;
     124                 :          1 :     pl_rect2df_aspect_fit(&rc, &rc1080p, 0.0);
     125         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_aspect(&rc), pl_rect2df_aspect(&rc1080p), 1e-6);
     126         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_midx(rc), pl_rect2df_midx(rc43), 1e-6);
     127         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect2df_midy(rc), pl_rect2df_midy(rc43), 1e-6);
     128         [ -  + ]:          1 :     REQUIRE_FEQ(pl_rect_w(rc), pl_rect_w(rc43), 1e-6);
     129                 :            : 
     130                 :          1 :     rc = (pl_rect2df) { 1920, 1080, 0, 0 };
     131                 :          1 :     pl_rect2df_offset(&rc, 50, 100);
     132         [ -  + ]:          1 :     REQUIRE_FEQ(rc.x0, 1870, 1e-6);
     133         [ -  + ]:          1 :     REQUIRE_FEQ(rc.x1, -50, 1e-6);
     134         [ -  + ]:          1 :     REQUIRE_FEQ(rc.y0, 980, 1e-6);
     135         [ -  + ]:          1 :     REQUIRE_FEQ(rc.y1, -100, 1e-6);
     136                 :            : }

Generated by: LCOV version 1.16