src/gromacs/utility/tests/enumerationhelpers.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2019, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief Tests for enumeration helpers
  37  *
  38  * \author Mark Abraham <mark.j.abraham@gmail.com>
  39  * \ingroup module_utility
  40  */
  41 #include "gmxpre.h"
  42
  43 #include "gromacs/utility/enumerationhelpers.h"
  44
  45 #include <iostream>
  46
  47 #include <gtest/gtest.h>
  48
  49 #include "gromacs/utility/arrayref.h"
  50
  51 namespace gmx
  52 {
  53 namespace
  54 {
  55
  56 //! Type to use in testing
  57 enum class Foo
  58 {
  59     Bar,
  60     Baz,
  61     Fooz,
  62     Count
  63 };
  64
  65 TEST(EnumerationHelpersTest, EnumerationWrapperWorks)
  66 {
  67     EnumerationWrapper<Foo> iter;
  68
  69     // Range-based for works
  70     int i = 0;
  71     for (Foo c : iter)
  72     {
  73         EXPECT_EQ(static_cast<int>(c), i++);
  74     }
  75
  76     // Normal iterators work
  77     i = 0;
  78     for (auto c = iter.begin(); c != iter.end(); ++c)
  79     {
  80         EXPECT_EQ(static_cast<int>(*c), i++);
  81     }
  82
  83     auto a = std::begin(iter);
  84     auto b = std::begin(iter);
  85
  86     ASSERT_EQ(a, b);
  87     ASSERT_EQ(*(a++), Foo::Bar);
  88     ASSERT_EQ(*(++b), Foo::Baz);
  89 }
  90
  91 TEST(EnumerationHelpersTest, EnumerationArrayWorks)
  92 {
  93     using FooArray = EnumerationArray<Foo, std::string>;
  94     const FooArray fooStrings{ { "Bar", "Baz", "Fooz" } };
  95
  96     // Keys give you the constants associated with each array index.
  97     int i = 0;
  98     for (auto k : FooArray::keys())
  99     {
 100         EXPECT_EQ(static_cast<int>(k), i++);
 101     }
 102
 103     // Keys give you the constants associated with each array index.
 104     i = 0;
 105     for (auto k : keysOf(fooStrings))
 106     {
 107         EXPECT_EQ(static_cast<int>(k), i++);
 108     }
 109
 110     // Using iterators and operator[] gives the array values.
 111     i = 0;
 112     for (const auto& s : fooStrings)
 113     {
 114         EXPECT_EQ(s, fooStrings[i++]);
 115     }
 116
 117     // Using reverse iterators gives the array values.
 118     i = 2;
 119     for (auto s = fooStrings.rbegin(); s != fooStrings.rend(); ++s)
 120     {
 121         EXPECT_EQ((*s), fooStrings[i--]);
 122     }
 123
 124     // Incrementing iterators works
 125     auto x = std::begin(fooStrings);
 126     EXPECT_EQ(*x, "Bar");
 127     ++x;
 128     EXPECT_EQ(*x, "Baz");
 129     ++x;
 130     EXPECT_EQ(*x, "Fooz");
 131
 132     // Operator[] can be used with enumeration values.
 133     EXPECT_EQ(fooStrings[Foo::Bar], "Bar");
 134     EXPECT_EQ(fooStrings[Foo::Baz], "Baz");
 135     EXPECT_EQ(fooStrings[Foo::Fooz], "Fooz");
 136 }
 137
 138 //! Helper function
 139 void func(ArrayRef<const int> a)
 140 {
 141     EXPECT_EQ(3, a[1]);
 142 }
 143
 144 TEST(EnumerationHelpersTest, ArrayRefOfEnumerationArrayWorks)
 145 {
 146     using FooArray = EnumerationArray<Foo, int>;
 147
 148     FooArray counts = { { 2, 3, 1 } };
 149
 150     // Test that explicit conversion works
 151     ArrayRef<const int> arrayRef(counts);
 152     EXPECT_EQ(3, arrayRef[1]);
 153
 154     // Test that implicit conversion works
 155     func(counts);
 156
 157     // Note that ArrayRef<int> arrayRef(counts) does not compile, as
 158     // expected, but we can't test for that.
 159 }
 160
 161 } // namespace
 162 } // namespace gmx