LCOV - code coverage report
Current view: top level - gcc - ordered-hash-map-tests.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 135 135 100.0 %
Date: 2020-04-04 11:58:09 Functions: 7 7 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Unit tests for ordered-hash-map.h.
       2                 :            :    Copyright (C) 2015-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "tm.h"
      24                 :            : #include "opts.h"
      25                 :            : #include "hash-set.h"
      26                 :            : #include "fixed-value.h"
      27                 :            : #include "alias.h"
      28                 :            : #include "flags.h"
      29                 :            : #include "symtab.h"
      30                 :            : #include "tree-core.h"
      31                 :            : #include "stor-layout.h"
      32                 :            : #include "tree.h"
      33                 :            : #include "stringpool.h"
      34                 :            : #include "ordered-hash-map.h"
      35                 :            : #include "selftest.h"
      36                 :            : 
      37                 :            : #if CHECKING_P
      38                 :            : 
      39                 :            : namespace selftest {
      40                 :            : 
      41                 :            : /* Populate *OUT_KVS with the key/value pairs of M.  */
      42                 :            : 
      43                 :            : template <typename HashMap, typename Key, typename Value>
      44                 :            : static void
      45                 :         10 : get_kv_pairs (const HashMap &m,
      46                 :            :               auto_vec<std::pair<Key, Value> > *out_kvs)
      47                 :            : {
      48                 :         10 :   for (typename HashMap::iterator iter = m.begin ();
      49                 :         38 :        iter != m.end ();
      50                 :         38 :        ++iter)
      51                 :         28 :     out_kvs->safe_push (std::make_pair ((*iter).first, (*iter).second));
      52                 :         10 : }
      53                 :            : 
      54                 :            : /* Construct an ordered_hash_map <const char *, int> and verify that
      55                 :            :    various operations work correctly.  */
      56                 :            : 
      57                 :            : static void
      58                 :          2 : test_map_of_strings_to_int ()
      59                 :            : {
      60                 :          2 :   ordered_hash_map <const char *, int> m;
      61                 :            : 
      62                 :          2 :   const char *ostrich = "ostrich";
      63                 :          2 :   const char *elephant = "elephant";
      64                 :          2 :   const char *ant = "ant";
      65                 :          2 :   const char *spider = "spider";
      66                 :          2 :   const char *millipede = "Illacme plenipes";
      67                 :          2 :   const char *eric = "half a bee";
      68                 :            : 
      69                 :            :   /* A fresh hash_map should be empty.  */
      70                 :          2 :   ASSERT_EQ (0, m.elements ());
      71                 :          4 :   ASSERT_EQ (NULL, m.get (ostrich));
      72                 :            : 
      73                 :            :   /* Populate the hash_map.  */
      74                 :          2 :   ASSERT_EQ (false, m.put (ostrich, 2));
      75                 :          2 :   ASSERT_EQ (false, m.put (elephant, 4));
      76                 :          2 :   ASSERT_EQ (false, m.put (ant, 6));
      77                 :          2 :   ASSERT_EQ (false, m.put (spider, 8));
      78                 :          2 :   ASSERT_EQ (false, m.put (millipede, 750));
      79                 :          2 :   ASSERT_EQ (false, m.put (eric, 3));
      80                 :            : 
      81                 :            :   /* Verify that we can recover the stored values.  */
      82                 :          2 :   ASSERT_EQ (6, m.elements ());
      83                 :          4 :   ASSERT_EQ (2, *m.get (ostrich));
      84                 :          4 :   ASSERT_EQ (4, *m.get (elephant));
      85                 :          4 :   ASSERT_EQ (6, *m.get (ant));
      86                 :          4 :   ASSERT_EQ (8, *m.get (spider));
      87                 :          4 :   ASSERT_EQ (750, *m.get (millipede));
      88                 :          4 :   ASSERT_EQ (3, *m.get (eric));
      89                 :            : 
      90                 :            :   /* Verify that the order of insertion is preserved.  */
      91                 :          4 :   auto_vec<std::pair<const char *, int> > kvs;
      92                 :          2 :   get_kv_pairs (m, &kvs);
      93                 :          2 :   ASSERT_EQ (kvs.length (), 6);
      94                 :          2 :   ASSERT_EQ (kvs[0].first, ostrich);
      95                 :          2 :   ASSERT_EQ (kvs[0].second, 2);
      96                 :          2 :   ASSERT_EQ (kvs[1].first, elephant);
      97                 :          2 :   ASSERT_EQ (kvs[1].second, 4);
      98                 :          2 :   ASSERT_EQ (kvs[2].first, ant);
      99                 :          2 :   ASSERT_EQ (kvs[2].second, 6);
     100                 :          2 :   ASSERT_EQ (kvs[3].first, spider);
     101                 :          2 :   ASSERT_EQ (kvs[3].second, 8);
     102                 :          2 :   ASSERT_EQ (kvs[4].first, millipede);
     103                 :          2 :   ASSERT_EQ (kvs[4].second, 750);
     104                 :          2 :   ASSERT_EQ (kvs[5].first, eric);
     105                 :          2 :   ASSERT_EQ (kvs[5].second, 3);
     106                 :          2 : }
     107                 :            : 
     108                 :            : /* Construct an ordered_hash_map using int_hash and verify that various
     109                 :            :    operations work correctly.  */
     110                 :            : 
     111                 :            : static void
     112                 :          2 : test_map_of_int_to_strings ()
     113                 :            : {
     114                 :          2 :   const int EMPTY = -1;
     115                 :          2 :   const int DELETED = -2;
     116                 :          2 :   typedef int_hash <int, EMPTY, DELETED> int_hash_t;
     117                 :          2 :   ordered_hash_map <int_hash_t, const char *> m;
     118                 :            : 
     119                 :          2 :   const char *ostrich = "ostrich";
     120                 :          2 :   const char *elephant = "elephant";
     121                 :          2 :   const char *ant = "ant";
     122                 :          2 :   const char *spider = "spider";
     123                 :          2 :   const char *millipede = "Illacme plenipes";
     124                 :          2 :   const char *eric = "half a bee";
     125                 :            : 
     126                 :            :   /* A fresh hash_map should be empty.  */
     127                 :          2 :   ASSERT_EQ (0, m.elements ());
     128                 :          4 :   ASSERT_EQ (NULL, m.get (2));
     129                 :            : 
     130                 :            :   /* Populate the hash_map.  */
     131                 :          2 :   ASSERT_EQ (false, m.put (2, ostrich));
     132                 :          2 :   ASSERT_EQ (false, m.put (4, elephant));
     133                 :          2 :   ASSERT_EQ (false, m.put (6, ant));
     134                 :          2 :   ASSERT_EQ (false, m.put (8, spider));
     135                 :          2 :   ASSERT_EQ (false, m.put (750, millipede));
     136                 :          2 :   ASSERT_EQ (false, m.put (3, eric));
     137                 :            : 
     138                 :            :   /* Verify that we can recover the stored values.  */
     139                 :          2 :   ASSERT_EQ (6, m.elements ());
     140                 :          4 :   ASSERT_EQ (*m.get (2), ostrich);
     141                 :          4 :   ASSERT_EQ (*m.get (4), elephant);
     142                 :          4 :   ASSERT_EQ (*m.get (6), ant);
     143                 :          4 :   ASSERT_EQ (*m.get (8), spider);
     144                 :          4 :   ASSERT_EQ (*m.get (750), millipede);
     145                 :          4 :   ASSERT_EQ (*m.get (3), eric);
     146                 :            : 
     147                 :            :   /* Verify that the order of insertion is preserved.  */
     148                 :          4 :   auto_vec<std::pair<int, const char *> > kvs;
     149                 :          2 :   get_kv_pairs (m, &kvs);
     150                 :          2 :   ASSERT_EQ (kvs.length (), 6);
     151                 :          2 :   ASSERT_EQ (kvs[0].first, 2);
     152                 :          2 :   ASSERT_EQ (kvs[0].second, ostrich);
     153                 :          2 :   ASSERT_EQ (kvs[1].first, 4);
     154                 :          2 :   ASSERT_EQ (kvs[1].second, elephant);
     155                 :          2 :   ASSERT_EQ (kvs[2].first, 6);
     156                 :          2 :   ASSERT_EQ (kvs[2].second, ant);
     157                 :          2 :   ASSERT_EQ (kvs[3].first, 8);
     158                 :          2 :   ASSERT_EQ (kvs[3].second, spider);
     159                 :          2 :   ASSERT_EQ (kvs[4].first, 750);
     160                 :          2 :   ASSERT_EQ (kvs[4].second, millipede);
     161                 :          2 :   ASSERT_EQ (kvs[5].first, 3);
     162                 :          2 :   ASSERT_EQ (kvs[5].second, eric);
     163                 :          2 : }
     164                 :            : 
     165                 :            : /* Verify that we can remove items from an ordered_hash_map.  */
     166                 :            : 
     167                 :            : static void
     168                 :          2 : test_removal ()
     169                 :            : {
     170                 :          2 :   ordered_hash_map <const char *, int> m;
     171                 :            : 
     172                 :          2 :   const char *ostrich = "ostrich";
     173                 :          2 :   ASSERT_EQ (false, m.put (ostrich, 2));
     174                 :            : 
     175                 :          2 :   ASSERT_EQ (1, m.elements ());
     176                 :          4 :   ASSERT_EQ (2, *m.get (ostrich));
     177                 :            : 
     178                 :          2 :   {
     179                 :          2 :     auto_vec<std::pair<const char *, int> > kvs;
     180                 :          2 :     get_kv_pairs (m, &kvs);
     181                 :          2 :     ASSERT_EQ (kvs.length (), 1);
     182                 :          2 :     ASSERT_EQ (kvs[0].first, ostrich);
     183                 :          2 :     ASSERT_EQ (kvs[0].second, 2);
     184                 :            :   }
     185                 :            : 
     186                 :          2 :   m.remove (ostrich);
     187                 :            : 
     188                 :          2 :   ASSERT_EQ (0, m.elements ());
     189                 :          2 :   {
     190                 :          2 :     auto_vec<std::pair<const char *, int> > kvs;
     191                 :          2 :     get_kv_pairs (m, &kvs);
     192                 :          2 :     ASSERT_EQ (kvs.length (), 0);
     193                 :            :   }
     194                 :            : 
     195                 :            :   /* Reinsertion (with a different value).  */
     196                 :          2 :   ASSERT_EQ (false, m.put (ostrich, 42));
     197                 :          2 :   ASSERT_EQ (1, m.elements ());
     198                 :          4 :   ASSERT_EQ (42, *m.get (ostrich));
     199                 :          2 :   {
     200                 :          4 :     auto_vec<std::pair<const char *, int> > kvs;
     201                 :          2 :     get_kv_pairs (m, &kvs);
     202                 :          2 :     ASSERT_EQ (kvs.length (), 1);
     203                 :          2 :     ASSERT_EQ (kvs[0].first, ostrich);
     204                 :          2 :     ASSERT_EQ (kvs[0].second, 42);
     205                 :            :   }
     206                 :          2 : }
     207                 :            : 
     208                 :            : /* Verify that ordered_hash_map's copy-ctor works.  */
     209                 :            : 
     210                 :            : static void
     211                 :          2 : test_copy_ctor ()
     212                 :            : {
     213                 :          4 :   ordered_hash_map <const char *, int> m;
     214                 :            : 
     215                 :          2 :   const char *ostrich = "ostrich";
     216                 :          2 :   ASSERT_EQ (false, m.put (ostrich, 2));
     217                 :            : 
     218                 :          2 :   ASSERT_EQ (1, m.elements ());
     219                 :          4 :   ASSERT_EQ (2, *m.get (ostrich));
     220                 :            : 
     221                 :          2 :   ordered_hash_map <const char *, int> copy (m);
     222                 :          2 :   ASSERT_EQ (1, copy.elements ());
     223                 :          4 :   ASSERT_EQ (2, *copy.get (ostrich));
     224                 :            : 
     225                 :            :   /* Remove from source.  */
     226                 :          2 :   m.remove (ostrich);
     227                 :          2 :   ASSERT_EQ (0, m.elements ());
     228                 :            : 
     229                 :            :   /* Copy should be unaffected.  */
     230                 :          2 :   ASSERT_EQ (1, copy.elements ());
     231                 :          4 :   ASSERT_EQ (2, *copy.get (ostrich));
     232                 :          2 : }
     233                 :            : 
     234                 :            : /* Run all of the selftests within this file.  */
     235                 :            : 
     236                 :            : void
     237                 :          2 : ordered_hash_map_tests_cc_tests ()
     238                 :            : {
     239                 :          2 :   test_map_of_strings_to_int ();
     240                 :          2 :   test_map_of_int_to_strings ();
     241                 :          2 :   test_removal ();
     242                 :          2 :   test_copy_ctor ();
     243                 :          2 : }
     244                 :            : 
     245                 :            : } // namespace selftest
     246                 :            : 
     247                 :            : #endif /* CHECKING_P */

Generated by: LCOV version 1.0

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 --enable-host-shared. GCC test suite is run with the built compiler.