tests: Added GTests for base/types.cc

Change-Id: I9515735efdd452a9f8c98f37f4ec2c27120929f5
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21659
Reviewed-by: Bobby R. Bruce <bbruce@ucdavis.edu>
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Reviewed-by: Daniel Carvalho <odanrc@yahoo.com.br>
Maintainer: Bobby R. Bruce <bbruce@ucdavis.edu>
Maintainer: Jason Lowe-Power <jason@lowepower.com>
Tested-by: kokoro <noreply+kokoro@google.com>

src/base/SConscript

@@ -77,6 +77,7 @@ Source('time.cc')
 Source('trace.cc')
 GTest('trie.test', 'trie.test.cc')
 Source('types.cc')
+GTest('types.test', 'types.test.cc', 'types.cc')
 
 Source('loader/aout_object.cc')
 Source('loader/dtb_file.cc')

src/base/types.test.cc

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2019 The Regents of the University of California
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder.  You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Bobby R. Bruce
+ */
+
+#include <gtest/gtest.h>
+
+#include <sstream>
+
+#include "base/types.hh"
+
+/*
+ * The following test the Cycles class. Cycles is a wrapper for uint64_t.
+ * It overloads most commonly used operators.
+ */
+TEST(CyclesTest, NoCycles)
+{
+    Cycles cycles;
+    EXPECT_EQ(0, cycles);
+}
+
+TEST(CyclesTest, PrefixIncrement)
+{
+    Cycles cycles(0);
+    EXPECT_EQ(1, ++cycles);
+    EXPECT_EQ(2, ++cycles);
+    EXPECT_EQ(2, cycles);
+}
+
+
+TEST(CyclesTest, PrefixDecrement)
+{
+    Cycles cycles(10);
+    EXPECT_EQ(9, --cycles);
+    EXPECT_EQ(8, --cycles);
+    EXPECT_EQ(8, cycles);
+}
+
+TEST(CyclesTest, InPlaceAddition)
+{
+    Cycles cycles(12);
+    Cycles to_add(5);
+    cycles += to_add;
+    EXPECT_EQ(17, cycles);
+}
+
+TEST(CyclesTest, GreaterThanLessThan)
+{
+    Cycles one_cycle(1);
+    Cycles two_cycles(2);
+    EXPECT_TRUE(two_cycles > one_cycle);
+    EXPECT_TRUE(one_cycle < two_cycles);
+}
+
+TEST(CyclesTest, AddCycles)
+{
+    Cycles cycles_1(10);
+    Cycles cycles_2(15);
+    Cycles added = cycles_1 + cycles_2;
+    EXPECT_EQ(25, added);
+}
+
+TEST(CyclesTest, SubtractCycles)
+{
+    Cycles cycles_1(25);
+    Cycles cycles_2(1);
+    Cycles subtracted = cycles_1 - cycles_2;
+    EXPECT_EQ(24, subtracted);
+}
+
+TEST(CyclesTest, ShiftRight)
+{
+    Cycles cycles(1ULL << 40);
+    Cycles cycles_shifted = cycles >> 5;
+    EXPECT_EQ((1ULL << 35), cycles_shifted);
+}
+
+TEST(CyclesTest, ShiftLeft)
+{
+    Cycles cycles(1ULL << 40);
+    Cycles cycles_shifted = cycles << 20;
+    EXPECT_EQ((1ULL << 60), cycles_shifted);
+}
+
+TEST(CyclesTest, OutStream)
+{
+    Cycles cycles(56);
+    std::ostringstream ss;
+    ss << "The number of cycles is: " << cycles << std::endl;
+    EXPECT_EQ("The number of cycles is: 56\n", ss.str());
+}
+
+/*
+ * MicroPCRomBit is a constant. This simple test verifies it has not changed.
+ * The following MicroPC tests rely heavily on this constant.
+ */
+TEST(MicroPCTest, CheckMicroPCRomBit)
+{
+    EXPECT_EQ((1 << 15), MicroPCRomBit);
+}
+
+TEST(MicroPCTest, RomMicroPCTest)
+{
+    EXPECT_EQ(MicroPCRomBit + (1 << 8), romMicroPC(MicroPCRomBit + (1 << 8)));
+}
+
+TEST(MicroPCTest, NormalMicroPCTest)
+{
+    EXPECT_EQ((1 << 8), normalMicroPC((1 << 8) + MicroPCRomBit));
+}
+
+TEST(MicroPCTest, IsRomMicroPCTest)
+{
+    EXPECT_TRUE(isRomMicroPC(MicroPCRomBit + (1 << 8)));
+}
+
+TEST(MicroPCTest, IsNotRomMicroPCTest)
+{
+    EXPECT_FALSE(isRomMicroPC((1 << 8)));
+}
+
+/*
+ * Both the "floatToBits32" and "floatToBits64" functions use the standard
+ * union approach to carry out type punning. These checks are simple regression
+ * tests.
+ */
+TEST(TypesTest, FloatToBits32)
+{
+    EXPECT_EQ(0x3e828f5c, floatToBits32(0.255));
+}
+
+TEST(TypesTest, floatToBits64)
+{
+    EXPECT_EQ(0x3fd067dfe32a0664, floatToBits64(0.25634));
+}
+
+/*
+ * "floatToBits(double val)" and "floatToBits(float val)" are simple overloads
+ * for "floatToBits64" and "floatToBits32" respectively. Ergo, these tests
+ * check this is the case.
+ */
+TEST(TypesTest, floatsToBitsDoubleInput)
+{
+    double val = 0.84023;
+    EXPECT_EQ(floatToBits64(val), floatToBits(val));
+}
+
+TEST(TypesTest, floatsToBitsFloatInput)
+{
+    float val = 0.04567;
+    EXPECT_EQ(floatToBits32(val), floatToBits(val));
+}