| /* |
| * 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. |
| */ |
| |
| #include <gtest/gtest.h> |
| |
| #include <sstream> |
| |
| #include "base/types.hh" |
| |
| using namespace gem5; |
| |
| /* |
| * 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)); |
| } |