LCOV - code coverage report
Current view: top level - gcc/text-art - widget.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.8 % 153 145
Test Date: 2026-11-14 16:39:50 Functions: 82.6 % 23 19
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Hierarchical diagram elements.
       2              :    Copyright (C) 2023-2026 Free Software Foundation, Inc.
       3              :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4              : 
       5              : This file is part of GCC.
       6              : 
       7              : GCC is free software; you can redistribute it and/or modify it under
       8              : the terms of the GNU General Public License as published by the Free
       9              : Software Foundation; either version 3, or (at your option) any later
      10              : version.
      11              : 
      12              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15              : for more details.
      16              : 
      17              : You should have received a copy of the GNU General Public License
      18              : along with GCC; see the file COPYING3.  If not see
      19              : <http://www.gnu.org/licenses/>.  */
      20              : 
      21              : #include "config.h"
      22              : #define INCLUDE_VECTOR
      23              : #include "system.h"
      24              : #include "coretypes.h"
      25              : #include "pretty-print.h"
      26              : #include "selftest.h"
      27              : #include "text-art/selftests.h"
      28              : #include "text-art/widget.h"
      29              : 
      30              : using namespace text_art;
      31              : 
      32              : /* class text_art::widget.  */
      33              : 
      34              : canvas
      35         2845 : widget::to_canvas (const style_manager &style_mgr)
      36              : {
      37         2845 :   const canvas::size_t req_size = get_req_size ();
      38              : 
      39              :   /* For now we don't constrain the allocation; we give
      40              :      the widget the full size it requested, and widgets
      41              :      assume they got their full size request.  */
      42         2845 :   const canvas::size_t alloc_size = req_size;
      43              : 
      44         2845 :   set_alloc_rect (canvas::rect_t (canvas::coord_t (0, 0), alloc_size));
      45         2845 :   canvas c (alloc_size, style_mgr);
      46         2845 :   paint_to_canvas (c);
      47         2845 :   return c;
      48              : }
      49              : 
      50              : /* class text_art::vbox_widget : public text_art::container_widget.  */
      51              : 
      52              : const char *
      53            0 : vbox_widget::get_desc () const
      54              : {
      55            0 :   return "vbox_widget";
      56              : }
      57              : 
      58              : canvas::size_t
      59           76 : vbox_widget::calc_req_size ()
      60              : {
      61           76 :   canvas::size_t result (0, 0);
      62          381 :   for (auto &child : m_children)
      63              :     {
      64          305 :       canvas::size_t child_req_size = child->get_req_size();
      65          305 :       result.h += child_req_size.h;
      66          305 :       result.w = std::max (result.w, child_req_size.w);
      67              :     }
      68           76 :   return result;
      69              : }
      70              : 
      71              : void
      72           76 : vbox_widget::update_child_alloc_rects ()
      73              : {
      74           76 :   const int x = get_min_x ();
      75           76 :   int y = get_min_y ();
      76          381 :   for (auto &child : m_children)
      77              :     {
      78          305 :       child->set_alloc_rect
      79          610 :         (canvas::rect_t (canvas::coord_t (x, y),
      80              :                          canvas::size_t (get_alloc_w (),
      81          305 :                                          child->get_req_h ())));
      82          305 :       y += child->get_req_h ();
      83              :     }
      84           76 : }
      85              : 
      86              : /* class text_art::text_widget : public text_art::leaf_widget.  */
      87              : 
      88        39277 : text_widget::text_widget (styled_string str)
      89        39277 : : m_max_line_width (0)
      90              : {
      91              :   // Split STR into multiple styled strings, one per line.
      92        39277 :   std::vector<styled_unichar> current_line;
      93        39277 :   int current_line_width = 0;
      94      1347883 :   for (auto ch : str)
      95              :     {
      96      1308606 :       if (ch.get_code () == '\n')
      97              :         {
      98           12 :           m_max_line_width = std::max (m_max_line_width, current_line_width);
      99           12 :           m_lines.push_back (styled_string (std::move (current_line)));
     100           12 :           current_line.clear ();
     101           12 :           current_line_width = 0;
     102              :         }
     103              :       else
     104              :         {
     105      1308594 :           current_line.push_back (ch);
     106      1308594 :           current_line_width += ch.get_canvas_width ();
     107              :         }
     108      1308606 :     }
     109        39277 :   if (!current_line.empty ())
     110              :     {
     111        39273 :       m_max_line_width = std::max (m_max_line_width, current_line_width);
     112        39273 :       m_lines.push_back (styled_string (std::move (current_line)));
     113              :     }
     114        39277 : }
     115              : 
     116              : const char *
     117            0 : text_widget::get_desc () const
     118              : {
     119            0 :   return "text_widget";
     120              : }
     121              : 
     122              : canvas::size_t
     123        39050 : text_widget::calc_req_size ()
     124              : {
     125        39050 :   return canvas::size_t (m_max_line_width, m_lines.size ());
     126              : }
     127              : 
     128              : void
     129        39034 : text_widget::paint_to_canvas (canvas &canvas)
     130              : {
     131        39034 :   canvas::coord_t line_xy = get_top_left ();
     132        78076 :   for (auto &line : m_lines)
     133              :     {
     134        39042 :       canvas.paint_text (line_xy, line);
     135        39042 :       ++line_xy.y;
     136              :     }
     137        39034 : }
     138              : 
     139              : /* class text_art::canvas_widget : public text_art::leaf_widget.  */
     140              : 
     141              : const char *
     142            0 : canvas_widget::get_desc () const
     143              : {
     144            0 :   return "canvas_widget";
     145              : }
     146              : 
     147              : canvas::size_t
     148            4 : canvas_widget::calc_req_size ()
     149              : {
     150            4 :   return m_canvas.get_size ();
     151              : }
     152              : 
     153              : void
     154            4 : canvas_widget::paint_to_canvas (canvas &canvas)
     155              : {
     156           16 :   for (int y = 0; y < m_canvas.get_size ().h; y++)
     157           72 :     for (int x = 0; x < m_canvas.get_size ().w; x++)
     158              :       {
     159           60 :         canvas::coord_t rel_xy (x, y);
     160           60 :         canvas.paint (get_top_left () + rel_xy,
     161           60 :                       m_canvas.get (rel_xy));
     162              :       }
     163            4 : }
     164              : 
     165              : #if CHECKING_P
     166              : 
     167              : namespace selftest {
     168              : 
     169              : /* Concrete widget subclass for writing selftests.
     170              :    Requests a hard-coded size, and fills its allocated rectangle
     171              :    with a specific character.  */
     172              : 
     173            4 : class test_widget : public leaf_widget
     174              : {
     175              : public:
     176           20 :   test_widget (canvas::size_t size, char ch)
     177            4 :   : m_test_size (size), m_ch (ch)
     178              :   {}
     179              : 
     180            0 :   const char *get_desc () const final override
     181              :   {
     182            0 :     return "test_widget";
     183              :   }
     184           20 :   canvas::size_t calc_req_size () final override
     185              :   {
     186           20 :     return m_test_size;
     187              :   }
     188           20 :   void paint_to_canvas (canvas &canvas) final override
     189              :   {
     190           20 :     canvas.fill (get_alloc_rect (), canvas::cell_t (m_ch));
     191           20 :   }
     192              : 
     193              : private:
     194              :   canvas::size_t m_test_size;
     195              :   char m_ch;
     196              : };
     197              : 
     198              : static void
     199            4 : test_test_widget ()
     200              : {
     201            4 :   style_manager sm;
     202            4 :   test_widget w (canvas::size_t (3, 3), 'A');
     203            4 :   canvas c (w.to_canvas (sm));
     204            4 :   ASSERT_CANVAS_STREQ
     205              :     (c, false,
     206              :      ("AAA\n"
     207              :       "AAA\n"
     208              :       "AAA\n"));
     209            4 : }
     210              : 
     211              : static void
     212            4 : test_text_widget ()
     213              : {
     214            4 :   style_manager sm;
     215            4 :   text_widget w (styled_string (sm, "hello world"));
     216            4 :   canvas c (w.to_canvas (sm));
     217            4 :   ASSERT_CANVAS_STREQ
     218              :     (c, false,
     219              :      ("hello world\n"));
     220            4 : }
     221              : 
     222              : static void
     223            4 : test_multiline_text_widget ()
     224              : {
     225            4 :   style_manager sm;
     226              : 
     227              :   // Without trailing newline:
     228            4 :   {
     229            4 :     text_widget w (styled_string (sm, "hello\n world"));
     230            4 :     ASSERT_EQ (w.get_req_size ().w, 6);
     231            4 :     ASSERT_EQ (w.get_req_size ().h, 2);
     232            4 :     canvas c (w.to_canvas (sm));
     233            4 :     ASSERT_CANVAS_STREQ
     234              :       (c, false,
     235              :        ("hello\n world\n"));
     236            4 :   }
     237              : 
     238              :   // With trailing newline:
     239            4 :   {
     240            4 :     text_widget w (styled_string (sm, "hello\n world\n"));
     241            4 :     ASSERT_EQ (w.get_req_size ().w, 6);
     242            4 :     ASSERT_EQ (w.get_req_size ().h, 2);
     243            4 :     canvas c (w.to_canvas (sm));
     244            4 :     ASSERT_CANVAS_STREQ
     245              :       (c, false,
     246              :        ("hello\n world\n"));
     247            4 :   }
     248            4 : }
     249              : 
     250              : static void
     251            4 : test_wrapper_widget ()
     252              : {
     253            4 :   style_manager sm;
     254            4 :   wrapper_widget w (std::make_unique<test_widget> (canvas::size_t (3, 3), 'B'));
     255            4 :   canvas c (w.to_canvas (sm));
     256            4 :   ASSERT_CANVAS_STREQ
     257              :     (c, false,
     258              :      ("BBB\n"
     259              :       "BBB\n"
     260              :       "BBB\n"));
     261            4 : }
     262              : 
     263              : static void
     264            4 : test_empty_wrapper_widget ()
     265              : {
     266            4 :   style_manager sm;
     267            4 :   wrapper_widget w (nullptr);
     268            4 :   canvas c (w.to_canvas (sm));
     269            4 :   ASSERT_CANVAS_STREQ (c, false, "");
     270            4 : }
     271              : 
     272              : static void
     273            4 : test_vbox_1 ()
     274              : {
     275            4 :   style_manager sm;
     276            4 :   vbox_widget w;
     277           24 :   for (int i = 0; i < 5; i++)
     278           20 :     w.add_child
     279           20 :       (std::make_unique <text_widget>
     280           20 :        (styled_string::from_fmt (sm, nullptr,
     281              :                                  "this is line %i", i)));
     282            4 :   canvas c (w.to_canvas (sm));
     283            4 :   ASSERT_CANVAS_STREQ
     284              :     (c, false,
     285              :      ("this is line 0\n"
     286              :       "this is line 1\n"
     287              :       "this is line 2\n"
     288              :       "this is line 3\n"
     289              :       "this is line 4\n"));
     290            4 : }
     291              : 
     292              : static void
     293            4 : test_vbox_2 ()
     294              : {
     295            4 :   style_manager sm;
     296            4 :   vbox_widget w;
     297            4 :   w.add_child (std::make_unique<test_widget> (canvas::size_t (1, 3), 'A'));
     298            4 :   w.add_child (std::make_unique<test_widget> (canvas::size_t (4, 1), 'B'));
     299            4 :   w.add_child (std::make_unique<test_widget> (canvas::size_t (1, 2), 'C'));
     300            4 :   canvas c (w.to_canvas (sm));
     301            4 :   ASSERT_CANVAS_STREQ
     302              :     (c, false,
     303              :      ("AAAA\n"
     304              :       "AAAA\n"
     305              :       "AAAA\n"
     306              :       "BBBB\n"
     307              :       "CCCC\n"
     308              :       "CCCC\n"));
     309            4 : }
     310              : 
     311              : static void
     312            4 : test_canvas_widget ()
     313              : {
     314            4 :   style_manager sm;
     315            4 :   canvas inner_canvas (canvas::size_t (5, 3), sm);
     316            4 :   inner_canvas.fill (canvas::rect_t (canvas::coord_t (0, 0),
     317            4 :                                      canvas::size_t (5, 3)),
     318            4 :                      canvas::cell_t ('a'));
     319            4 :   canvas_widget cw (std::move (inner_canvas));
     320            4 :   canvas c (cw.to_canvas (sm));
     321            4 :   ASSERT_CANVAS_STREQ
     322              :     (c, false,
     323              :      ("aaaaa\n"
     324              :       "aaaaa\n"
     325              :       "aaaaa\n"));
     326            4 : }
     327              : 
     328              : /* Run all selftests in this file.  */
     329              : 
     330              : void
     331            4 : text_art_widget_cc_tests ()
     332              : {
     333            4 :   test_test_widget ();
     334            4 :   test_text_widget ();
     335            4 :   test_multiline_text_widget ();
     336            4 :   test_wrapper_widget ();
     337            4 :   test_empty_wrapper_widget ();
     338            4 :   test_vbox_1 ();
     339            4 :   test_vbox_2 ();
     340            4 :   test_canvas_widget ();
     341            4 : }
     342              : 
     343              : } // namespace selftest
     344              : 
     345              : 
     346              : #endif /* #if CHECKING_P */
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.