From: Gabe Black Date: Thu, 29 Nov 2018 01:36:28 +0000 (-0800) Subject: base: Rename unit test cc files to be *.test.cc. X-Git-Tag: v19.0.0.0~1354 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=66f028550496c67756d02f9127432e057beeafc8;p=gem5.git base: Rename unit test cc files to be *.test.cc. This makes the name easier to read, looks ok if the file is named with underscores between words or not, is easy to grep for, and shouldn't introduce any ambiguities in the file names. Change-Id: I34b7bcccea2d87c10c0de417dd5e3ef27c4b5666 Reviewed-on: https://gem5-review.googlesource.com/c/14676 Reviewed-by: Giacomo Travaglini Reviewed-by: Daniel Carvalho Maintainer: Gabe Black --- diff --git a/src/base/SConscript b/src/base/SConscript index b0893a145..673590371 100644 --- a/src/base/SConscript +++ b/src/base/SConscript @@ -40,26 +40,26 @@ Source('imgwriter.cc') Source('bmpwriter.cc') Source('callback.cc') Source('cprintf.cc', add_tags='gtest lib') -GTest('cprintftest', 'cprintftest.cc') +GTest('cprintftest', 'cprintf.test.cc') Source('debug.cc') if env['USE_FENV']: Source('fenv.c') if env['USE_PNG']: Source('pngwriter.cc') Source('fiber.cc') -GTest('fibertest', 'fibertest.cc', 'fiber.cc') -GTest('coroutinetest', 'coroutinetest.cc', 'fiber.cc') +GTest('fibertest', 'fiber.test.cc', 'fiber.cc') +GTest('coroutinetest', 'coroutine.test.cc', 'fiber.cc') Source('framebuffer.cc') Source('hostinfo.cc') Source('inet.cc') Source('inifile.cc') -GTest('inifiletest', 'inifiletest.cc', 'inifile.cc', 'str.cc') +GTest('inifiletest', 'inifile.test.cc', 'inifile.cc', 'str.cc') Source('intmath.cc') Source('logging.cc') Source('match.cc') Source('output.cc') Source('pixel.cc') -GTest('pixeltest', 'pixeltest.cc', 'pixel.cc') +GTest('pixeltest', 'pixel.test.cc', 'pixel.cc') Source('pollevent.cc') Source('random.cc') if env['TARGET_ISA'] != 'null': @@ -69,7 +69,7 @@ Source('statistics.cc') Source('str.cc') Source('time.cc') Source('trace.cc') -GTest('trietest', 'trietest.cc') +GTest('trietest', 'trie.test.cc') Source('types.cc') Source('loader/aout_object.cc') @@ -83,10 +83,10 @@ Source('loader/symtab.cc') Source('stats/text.cc') -GTest('addr_range_test', 'addr_range_test.cc') -GTest('AddrRangeMapTest', 'addr_range_map_test.cc') -GTest('bituniontest', 'bituniontest.cc') -GTest('CircleBufTest', 'circlebuftest.cc') +GTest('addr_range_test', 'addr_range.test.cc') +GTest('AddrRangeMapTest', 'addr_range_map.test.cc') +GTest('bituniontest', 'bitunion.test.cc') +GTest('CircleBufTest', 'circlebuf.test.cc') DebugFlag('Annotate', "State machine annotation debugging") DebugFlag('AnnotateQ', "State machine annotation queue debugging") diff --git a/src/base/addr_range.test.cc b/src/base/addr_range.test.cc new file mode 100644 index 000000000..9900c6c58 --- /dev/null +++ b/src/base/addr_range.test.cc @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2018 ARM Limited + * 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: Nikos Nikoleris + */ + +#include + +#include "base/addr_range.hh" + +TEST(AddrRangeComp, AddrRangeIsSubset) +{ + AddrRange r, r1, r2; + + // Test non-interleaved ranges + r1 = AddrRange(0x0, 0x7f); + r2 = AddrRange(0x80, 0xff); + + r = AddrRange(0x0, 0xf); + EXPECT_TRUE(r.isSubset(r1)); + EXPECT_FALSE(r.isSubset(r2)); + + r = AddrRange(0x80, 0x8f); + EXPECT_FALSE(r.isSubset(r1)); + EXPECT_TRUE(r.isSubset(r2)); + + // Test interleaved ranges + r1 = AddrRange(0x0, 0xff, 6, 0, 1, 0); + r2 = AddrRange(0x0, 0xff, 6, 0, 1, 1); + + r = AddrRange(0x0, 0xf); + EXPECT_TRUE(r.isSubset(r1)); + EXPECT_FALSE(r.isSubset(r2)); + + r = AddrRange(0x40, 0x4f); + EXPECT_FALSE(r.isSubset(r1)); + EXPECT_TRUE(r.isSubset(r2)); + + r = AddrRange(0xbf, 0xc0); + EXPECT_FALSE(r.isSubset(r1)); + EXPECT_FALSE(r.isSubset(r2)); + + // Test interleaved ranges with hashing + r1 = AddrRange(0x0, 0xff, 6, 7, 1, 0); + r2 = AddrRange(0x0, 0xff, 6, 7, 1, 1); + + r = AddrRange(0x0, 0xf); + EXPECT_TRUE(r.isSubset(r1)); + EXPECT_FALSE(r.isSubset(r2)); + + r = AddrRange(0x40, 0x4f); + EXPECT_FALSE(r.isSubset(r1)); + EXPECT_TRUE(r.isSubset(r2)); + + r = AddrRange(0xbf, 0xc0); + EXPECT_FALSE(r.isSubset(r1)); + EXPECT_FALSE(r.isSubset(r2)); +} diff --git a/src/base/addr_range_map.test.cc b/src/base/addr_range_map.test.cc new file mode 100644 index 000000000..397372c06 --- /dev/null +++ b/src/base/addr_range_map.test.cc @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2012, 2018 ARM Limited + * 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. + * + * Copyright (c) 2006 The Regents of The University of Michigan + * All rights reserved. + * + * 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: Ali Saidi + */ + +#include + +#include "base/addr_range_map.hh" + +// Converted from legacy unit test framework +TEST(AddrRangeMapTest, LegacyTests) +{ + AddrRangeMap r; + AddrRangeMap::const_iterator i; + + i = r.insert(RangeIn(10, 40), 5); + ASSERT_NE(i, r.end()); + + i = r.insert(RangeIn(60, 90), 3); + ASSERT_NE(i, r.end()); + + EXPECT_NE(r.intersects(RangeIn(20, 30)), r.end()); + EXPECT_EQ(r.contains(RangeIn(55, 55)), r.end()); + EXPECT_EQ(r.intersects(RangeIn(55, 55)), r.end()); + + i = r.insert(RangeIn(0, 12), 1); + EXPECT_EQ(i, r.end()); + + i = r.insert(RangeIn(0, 9), 1); + ASSERT_NE(i, r.end()); + + EXPECT_NE(r.contains(RangeIn(20, 30)), r.end()); +} diff --git a/src/base/addr_range_map_test.cc b/src/base/addr_range_map_test.cc deleted file mode 100644 index 397372c06..000000000 --- a/src/base/addr_range_map_test.cc +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2012, 2018 ARM Limited - * 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. - * - * Copyright (c) 2006 The Regents of The University of Michigan - * All rights reserved. - * - * 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: Ali Saidi - */ - -#include - -#include "base/addr_range_map.hh" - -// Converted from legacy unit test framework -TEST(AddrRangeMapTest, LegacyTests) -{ - AddrRangeMap r; - AddrRangeMap::const_iterator i; - - i = r.insert(RangeIn(10, 40), 5); - ASSERT_NE(i, r.end()); - - i = r.insert(RangeIn(60, 90), 3); - ASSERT_NE(i, r.end()); - - EXPECT_NE(r.intersects(RangeIn(20, 30)), r.end()); - EXPECT_EQ(r.contains(RangeIn(55, 55)), r.end()); - EXPECT_EQ(r.intersects(RangeIn(55, 55)), r.end()); - - i = r.insert(RangeIn(0, 12), 1); - EXPECT_EQ(i, r.end()); - - i = r.insert(RangeIn(0, 9), 1); - ASSERT_NE(i, r.end()); - - EXPECT_NE(r.contains(RangeIn(20, 30)), r.end()); -} diff --git a/src/base/addr_range_test.cc b/src/base/addr_range_test.cc deleted file mode 100644 index 9900c6c58..000000000 --- a/src/base/addr_range_test.cc +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) 2018 ARM Limited - * 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: Nikos Nikoleris - */ - -#include - -#include "base/addr_range.hh" - -TEST(AddrRangeComp, AddrRangeIsSubset) -{ - AddrRange r, r1, r2; - - // Test non-interleaved ranges - r1 = AddrRange(0x0, 0x7f); - r2 = AddrRange(0x80, 0xff); - - r = AddrRange(0x0, 0xf); - EXPECT_TRUE(r.isSubset(r1)); - EXPECT_FALSE(r.isSubset(r2)); - - r = AddrRange(0x80, 0x8f); - EXPECT_FALSE(r.isSubset(r1)); - EXPECT_TRUE(r.isSubset(r2)); - - // Test interleaved ranges - r1 = AddrRange(0x0, 0xff, 6, 0, 1, 0); - r2 = AddrRange(0x0, 0xff, 6, 0, 1, 1); - - r = AddrRange(0x0, 0xf); - EXPECT_TRUE(r.isSubset(r1)); - EXPECT_FALSE(r.isSubset(r2)); - - r = AddrRange(0x40, 0x4f); - EXPECT_FALSE(r.isSubset(r1)); - EXPECT_TRUE(r.isSubset(r2)); - - r = AddrRange(0xbf, 0xc0); - EXPECT_FALSE(r.isSubset(r1)); - EXPECT_FALSE(r.isSubset(r2)); - - // Test interleaved ranges with hashing - r1 = AddrRange(0x0, 0xff, 6, 7, 1, 0); - r2 = AddrRange(0x0, 0xff, 6, 7, 1, 1); - - r = AddrRange(0x0, 0xf); - EXPECT_TRUE(r.isSubset(r1)); - EXPECT_FALSE(r.isSubset(r2)); - - r = AddrRange(0x40, 0x4f); - EXPECT_FALSE(r.isSubset(r1)); - EXPECT_TRUE(r.isSubset(r2)); - - r = AddrRange(0xbf, 0xc0); - EXPECT_FALSE(r.isSubset(r1)); - EXPECT_FALSE(r.isSubset(r2)); -} diff --git a/src/base/bitunion.test.cc b/src/base/bitunion.test.cc new file mode 100644 index 000000000..d7ed95bb8 --- /dev/null +++ b/src/base/bitunion.test.cc @@ -0,0 +1,286 @@ +/* + * Copyright 2014 Google, Inc. + * + * 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: Gabe Black + */ + +#include + +#include +#include +#include + +#include "base/bitunion.hh" +#include "base/cprintf.hh" + +using namespace std; + +namespace { + +BitUnion64(SixtyFour) + Bitfield<39, 32> byte5; + Bitfield<2> bit2; + BitfieldRO<39, 32> byte5RO; + BitfieldWO<39, 32> byte5WO; + SubBitUnion(byte6, 47, 40) + Bitfield<43, 42> bits43To42; + Bitfield<41> bit41; + SignedBitfield<41> bit41Signed; + EndSubBitUnion(byte6) + SignedBitfield<47, 40> byte6Signed; + SignedBitfieldRO<47, 40> byte6SignedRO; + SignedBitfieldWO<47, 40> byte6SignedWO; +EndBitUnion(SixtyFour) + +BitUnion64(EmptySixtyFour) +EndBitUnion(EmptySixtyFour) + +BitUnion32(EmptyThirtyTwo) +EndBitUnion(EmptyThirtyTwo) + +BitUnion16(EmptySixteen) +EndBitUnion(EmptySixteen) + +BitUnion8(EmptyEight) +EndBitUnion(EmptyEight) + +class SplitField +{ + protected: + BitUnion64(In) + Bitfield<15, 12> high; + Bitfield<7, 4> low; + EndBitUnion(In) + + BitUnion64(Out) + Bitfield<7, 4> high; + Bitfield<3, 0> low; + EndBitUnion(Out) + public: + uint64_t + getter(const uint64_t &storage) const + { + Out out = 0; + In in = storage; + out.high = in.high; + out.low = in.low; + return out; + } + + void + setter(uint64_t &storage, uint64_t val) + { + Out out = val; + In in = 0; + in.high = out.high; + in.low = out.low; + storage = in; + } +}; + +BitUnion64(Split) + BitfieldType split; +EndBitUnion(Split) + +struct ContainingStruct +{ + BitUnion64(Contained) + Bitfield<63, 60> topNibble; + EndBitUnion(Contained) + + Contained contained; +}; + +uint64_t +containingFunc(uint64_t init_val, uint64_t fieldVal) +{ + BitUnion32(Contained) + Bitfield<16, 15> field; + EndBitUnion(Contained) + + Contained contained = init_val; + contained.field = fieldVal; + return contained; +} + +} // anonymous namespace + +// Declare these as global so g++ doesn't ignore them. Initialize them in +// various ways. +EmptySixtyFour emptySixtyFour = 0; +EmptyThirtyTwo emptyThirtyTwo; +EmptySixteen emptySixteen; +EmptyEight emptyEight(0); + +class BitUnionData : public testing::Test { + protected: + SixtyFour sixtyFour; + Split split; + + void SetUp() override { sixtyFour = 0; split = 0; } + + template + uint64_t templatedFunction(T) { return 0; } + + template + uint64_t + templatedFunction(BitUnionType u) + { + BitUnionBaseType b = u; + return b; + } +}; + +TEST_F(BitUnionData, NormalBitfield) +{ + EXPECT_EQ(sixtyFour.byte5, 0); + sixtyFour.byte5 = 0xff; + EXPECT_EQ(sixtyFour, 0xff00000000); + sixtyFour.byte5 = 0xfff; + EXPECT_EQ(sixtyFour, 0xff00000000); + EXPECT_EQ(sixtyFour.byte5, 0xff); +} + +TEST_F(BitUnionData, SingleBitfield) +{ + EXPECT_EQ(sixtyFour.bit2, 0); + sixtyFour.bit2 = 0x1; + EXPECT_EQ(sixtyFour, 0x4); + EXPECT_EQ(sixtyFour.bit2, 0x1); +} + +TEST_F(BitUnionData, ReadOnlyBitfield) +{ + EXPECT_EQ(sixtyFour.byte5RO, 0); + sixtyFour.byte5 = 0xff; + EXPECT_EQ(sixtyFour.byte5RO, 0xff); +} + +TEST_F(BitUnionData, WriteOnlyBitfield) +{ + sixtyFour.byte5WO = 0xff; + EXPECT_EQ(sixtyFour, 0xff00000000); +} + +TEST_F(BitUnionData, SubBitUnions) +{ + EXPECT_EQ(sixtyFour.byte6.bit41, 0); + sixtyFour.byte6 = 0x2; + EXPECT_EQ(sixtyFour.byte6.bit41, 1); + sixtyFour.byte6.bits43To42 = 0x3; + EXPECT_EQ(sixtyFour.byte6, 0xe); + sixtyFour.byte6 = 0xff; + sixtyFour.byte6.bit41 = 0; + EXPECT_EQ(sixtyFour, 0xfd0000000000); +} + +TEST_F(BitUnionData, SignedBitfields) +{ + sixtyFour.byte6 = 0xff; + EXPECT_EQ(sixtyFour.byte6Signed, -1); + EXPECT_EQ(sixtyFour.byte6SignedRO, -1); + sixtyFour.byte6SignedWO = 0; + EXPECT_EQ(sixtyFour.byte6Signed, 0); + EXPECT_EQ(sixtyFour.byte6SignedRO, 0); + EXPECT_EQ(sixtyFour.byte6, 0); +} + +TEST_F(BitUnionData, InsideStruct) +{ + ContainingStruct containing; + containing.contained = 0; + containing.contained.topNibble = 0xd; + EXPECT_EQ(containing.contained, 0xd000000000000000); +} + +TEST_F(BitUnionData, InsideFunction) +{ + EXPECT_EQ(containingFunc(0xfffff, 0), 0xe7fff); +} + +TEST_F(BitUnionData, BitfieldToBitfieldAssignment) +{ + SixtyFour otherSixtyFour = 0; + sixtyFour.bit2 = 1; + otherSixtyFour.byte6.bit41 = sixtyFour.bit2; + EXPECT_EQ(otherSixtyFour, 0x20000000000); + otherSixtyFour.bit2 = sixtyFour.bit2; + EXPECT_EQ(otherSixtyFour, 0x20000000004); +} + +TEST_F(BitUnionData, Operators) +{ + SixtyFour otherSixtyFour = 0x4; + sixtyFour = otherSixtyFour; + EXPECT_EQ(sixtyFour, 0x4); + sixtyFour = 0; + EXPECT_TRUE(sixtyFour < otherSixtyFour); + EXPECT_TRUE(otherSixtyFour > sixtyFour); + EXPECT_TRUE(sixtyFour != otherSixtyFour); + sixtyFour = otherSixtyFour; + EXPECT_TRUE(sixtyFour == otherSixtyFour); +} + +TEST_F(BitUnionData, Custom) +{ + EXPECT_EQ(split, 0); + split.split = 0xfff; + EXPECT_EQ(split, 0xf0f0); + EXPECT_EQ((uint64_t)split.split, 0xff); +} + +TEST_F(BitUnionData, Templating) +{ + sixtyFour = 0xff; + EXPECT_EQ(templatedFunction(sixtyFour), 0xff); + EXPECT_EQ(templatedFunction((uint64_t)sixtyFour), 0); + + BitUnion(uint64_t, Dummy64) + EndBitUnion(Dummy64); + + BitUnion(uint32_t, Dummy32) + EndBitUnion(Dummy32); + + bool is64; + is64 = std::is_same, uint64_t>::value; + EXPECT_TRUE(is64); + is64 = std::is_same, uint64_t>::value; + EXPECT_FALSE(is64); +} + +TEST_F(BitUnionData, Output) +{ + sixtyFour = 1234567812345678; + std::stringstream ss; + ss << sixtyFour; + EXPECT_EQ(ss.str(), "1234567812345678"); + ss.str(""); + + EmptyEight eight = 65; + ss << eight; + EXPECT_EQ(ss.str(), "65"); + ss.str(""); +} diff --git a/src/base/bituniontest.cc b/src/base/bituniontest.cc deleted file mode 100644 index d7ed95bb8..000000000 --- a/src/base/bituniontest.cc +++ /dev/null @@ -1,286 +0,0 @@ -/* - * Copyright 2014 Google, Inc. - * - * 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: Gabe Black - */ - -#include - -#include -#include -#include - -#include "base/bitunion.hh" -#include "base/cprintf.hh" - -using namespace std; - -namespace { - -BitUnion64(SixtyFour) - Bitfield<39, 32> byte5; - Bitfield<2> bit2; - BitfieldRO<39, 32> byte5RO; - BitfieldWO<39, 32> byte5WO; - SubBitUnion(byte6, 47, 40) - Bitfield<43, 42> bits43To42; - Bitfield<41> bit41; - SignedBitfield<41> bit41Signed; - EndSubBitUnion(byte6) - SignedBitfield<47, 40> byte6Signed; - SignedBitfieldRO<47, 40> byte6SignedRO; - SignedBitfieldWO<47, 40> byte6SignedWO; -EndBitUnion(SixtyFour) - -BitUnion64(EmptySixtyFour) -EndBitUnion(EmptySixtyFour) - -BitUnion32(EmptyThirtyTwo) -EndBitUnion(EmptyThirtyTwo) - -BitUnion16(EmptySixteen) -EndBitUnion(EmptySixteen) - -BitUnion8(EmptyEight) -EndBitUnion(EmptyEight) - -class SplitField -{ - protected: - BitUnion64(In) - Bitfield<15, 12> high; - Bitfield<7, 4> low; - EndBitUnion(In) - - BitUnion64(Out) - Bitfield<7, 4> high; - Bitfield<3, 0> low; - EndBitUnion(Out) - public: - uint64_t - getter(const uint64_t &storage) const - { - Out out = 0; - In in = storage; - out.high = in.high; - out.low = in.low; - return out; - } - - void - setter(uint64_t &storage, uint64_t val) - { - Out out = val; - In in = 0; - in.high = out.high; - in.low = out.low; - storage = in; - } -}; - -BitUnion64(Split) - BitfieldType split; -EndBitUnion(Split) - -struct ContainingStruct -{ - BitUnion64(Contained) - Bitfield<63, 60> topNibble; - EndBitUnion(Contained) - - Contained contained; -}; - -uint64_t -containingFunc(uint64_t init_val, uint64_t fieldVal) -{ - BitUnion32(Contained) - Bitfield<16, 15> field; - EndBitUnion(Contained) - - Contained contained = init_val; - contained.field = fieldVal; - return contained; -} - -} // anonymous namespace - -// Declare these as global so g++ doesn't ignore them. Initialize them in -// various ways. -EmptySixtyFour emptySixtyFour = 0; -EmptyThirtyTwo emptyThirtyTwo; -EmptySixteen emptySixteen; -EmptyEight emptyEight(0); - -class BitUnionData : public testing::Test { - protected: - SixtyFour sixtyFour; - Split split; - - void SetUp() override { sixtyFour = 0; split = 0; } - - template - uint64_t templatedFunction(T) { return 0; } - - template - uint64_t - templatedFunction(BitUnionType u) - { - BitUnionBaseType b = u; - return b; - } -}; - -TEST_F(BitUnionData, NormalBitfield) -{ - EXPECT_EQ(sixtyFour.byte5, 0); - sixtyFour.byte5 = 0xff; - EXPECT_EQ(sixtyFour, 0xff00000000); - sixtyFour.byte5 = 0xfff; - EXPECT_EQ(sixtyFour, 0xff00000000); - EXPECT_EQ(sixtyFour.byte5, 0xff); -} - -TEST_F(BitUnionData, SingleBitfield) -{ - EXPECT_EQ(sixtyFour.bit2, 0); - sixtyFour.bit2 = 0x1; - EXPECT_EQ(sixtyFour, 0x4); - EXPECT_EQ(sixtyFour.bit2, 0x1); -} - -TEST_F(BitUnionData, ReadOnlyBitfield) -{ - EXPECT_EQ(sixtyFour.byte5RO, 0); - sixtyFour.byte5 = 0xff; - EXPECT_EQ(sixtyFour.byte5RO, 0xff); -} - -TEST_F(BitUnionData, WriteOnlyBitfield) -{ - sixtyFour.byte5WO = 0xff; - EXPECT_EQ(sixtyFour, 0xff00000000); -} - -TEST_F(BitUnionData, SubBitUnions) -{ - EXPECT_EQ(sixtyFour.byte6.bit41, 0); - sixtyFour.byte6 = 0x2; - EXPECT_EQ(sixtyFour.byte6.bit41, 1); - sixtyFour.byte6.bits43To42 = 0x3; - EXPECT_EQ(sixtyFour.byte6, 0xe); - sixtyFour.byte6 = 0xff; - sixtyFour.byte6.bit41 = 0; - EXPECT_EQ(sixtyFour, 0xfd0000000000); -} - -TEST_F(BitUnionData, SignedBitfields) -{ - sixtyFour.byte6 = 0xff; - EXPECT_EQ(sixtyFour.byte6Signed, -1); - EXPECT_EQ(sixtyFour.byte6SignedRO, -1); - sixtyFour.byte6SignedWO = 0; - EXPECT_EQ(sixtyFour.byte6Signed, 0); - EXPECT_EQ(sixtyFour.byte6SignedRO, 0); - EXPECT_EQ(sixtyFour.byte6, 0); -} - -TEST_F(BitUnionData, InsideStruct) -{ - ContainingStruct containing; - containing.contained = 0; - containing.contained.topNibble = 0xd; - EXPECT_EQ(containing.contained, 0xd000000000000000); -} - -TEST_F(BitUnionData, InsideFunction) -{ - EXPECT_EQ(containingFunc(0xfffff, 0), 0xe7fff); -} - -TEST_F(BitUnionData, BitfieldToBitfieldAssignment) -{ - SixtyFour otherSixtyFour = 0; - sixtyFour.bit2 = 1; - otherSixtyFour.byte6.bit41 = sixtyFour.bit2; - EXPECT_EQ(otherSixtyFour, 0x20000000000); - otherSixtyFour.bit2 = sixtyFour.bit2; - EXPECT_EQ(otherSixtyFour, 0x20000000004); -} - -TEST_F(BitUnionData, Operators) -{ - SixtyFour otherSixtyFour = 0x4; - sixtyFour = otherSixtyFour; - EXPECT_EQ(sixtyFour, 0x4); - sixtyFour = 0; - EXPECT_TRUE(sixtyFour < otherSixtyFour); - EXPECT_TRUE(otherSixtyFour > sixtyFour); - EXPECT_TRUE(sixtyFour != otherSixtyFour); - sixtyFour = otherSixtyFour; - EXPECT_TRUE(sixtyFour == otherSixtyFour); -} - -TEST_F(BitUnionData, Custom) -{ - EXPECT_EQ(split, 0); - split.split = 0xfff; - EXPECT_EQ(split, 0xf0f0); - EXPECT_EQ((uint64_t)split.split, 0xff); -} - -TEST_F(BitUnionData, Templating) -{ - sixtyFour = 0xff; - EXPECT_EQ(templatedFunction(sixtyFour), 0xff); - EXPECT_EQ(templatedFunction((uint64_t)sixtyFour), 0); - - BitUnion(uint64_t, Dummy64) - EndBitUnion(Dummy64); - - BitUnion(uint32_t, Dummy32) - EndBitUnion(Dummy32); - - bool is64; - is64 = std::is_same, uint64_t>::value; - EXPECT_TRUE(is64); - is64 = std::is_same, uint64_t>::value; - EXPECT_FALSE(is64); -} - -TEST_F(BitUnionData, Output) -{ - sixtyFour = 1234567812345678; - std::stringstream ss; - ss << sixtyFour; - EXPECT_EQ(ss.str(), "1234567812345678"); - ss.str(""); - - EmptyEight eight = 65; - ss << eight; - EXPECT_EQ(ss.str(), "65"); - ss.str(""); -} diff --git a/src/base/circlebuf.test.cc b/src/base/circlebuf.test.cc new file mode 100644 index 000000000..9f5679d84 --- /dev/null +++ b/src/base/circlebuf.test.cc @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2015, 2018 ARM Limited + * 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: Andreas Sandberg + */ + +#include + +#include "base/circlebuf.hh" + +const char data[] = { + 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, + 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, +}; + +// Basic non-overflow functionality +TEST(CircleBufTest, BasicReadWriteNoOverflow) +{ + CircleBuf buf(8); + char foo[16]; + + // Write empty buffer, no overflow + buf.write(data, 8); + EXPECT_EQ(buf.size(), 8); + buf.peek(foo, 8); + EXPECT_EQ(memcmp(foo, data, 8), 0); + + // Read 2 + buf.read(foo, 2); + EXPECT_EQ(memcmp(foo, data, 2), 0); + EXPECT_EQ(buf.size(), 6); + buf.read(foo, 6); + EXPECT_EQ(memcmp(foo, data + 2, 6), 0); + EXPECT_EQ(buf.size(), 0); +} + +// Basic single write overflow functionality +TEST(CircleBufTest, SingleWriteOverflow) +{ + CircleBuf buf(8); + char foo[16]; + + buf.write(data, 16); + EXPECT_EQ(buf.size(), 8); + buf.peek(foo, 8); + EXPECT_EQ(memcmp(data + 8, foo, 8), 0); +} + + +// Multi-write overflow functionality +TEST(CircleBufTest, MultiWriteOverflow) +{ + CircleBuf buf(8); + char foo[16]; + + // Write, no overflow, write overflow + buf.write(data, 6); + buf.write(data + 8, 6); + EXPECT_EQ(buf.size(), 8); + buf.peek(foo, 8); + EXPECT_EQ(memcmp(data + 4, foo, 2), 0); + EXPECT_EQ(memcmp(data + 8, foo + 2, 6), 0); +} + +// Pointer wrap around +TEST(CircleBufTest, PointerWrapAround) +{ + CircleBuf buf(8); + char foo[16]; + + // _start == 0, _stop = 8 + buf.write(data, 8); + // _start == 4, _stop = 8 + buf.read(foo, 4); + // _start == 4, _stop = 12 + buf.write(data + 8, 4); + EXPECT_EQ(buf.size(), 8); + // _start == 10, _stop = 12 + // Normalized: _start == 2, _stop = 4 + buf.read(foo + 4, 6); + EXPECT_EQ(buf.size(), 2); + EXPECT_EQ(memcmp(data, foo, 10), 0); + // Normalized: _start == 4, _stop = 4 + buf.read(foo + 10, 2); + EXPECT_EQ(buf.size(), 0); + EXPECT_EQ(memcmp(data, foo, 12), 0); +} diff --git a/src/base/circlebuftest.cc b/src/base/circlebuftest.cc deleted file mode 100644 index 9f5679d84..000000000 --- a/src/base/circlebuftest.cc +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (c) 2015, 2018 ARM Limited - * 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: Andreas Sandberg - */ - -#include - -#include "base/circlebuf.hh" - -const char data[] = { - 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, - 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, -}; - -// Basic non-overflow functionality -TEST(CircleBufTest, BasicReadWriteNoOverflow) -{ - CircleBuf buf(8); - char foo[16]; - - // Write empty buffer, no overflow - buf.write(data, 8); - EXPECT_EQ(buf.size(), 8); - buf.peek(foo, 8); - EXPECT_EQ(memcmp(foo, data, 8), 0); - - // Read 2 - buf.read(foo, 2); - EXPECT_EQ(memcmp(foo, data, 2), 0); - EXPECT_EQ(buf.size(), 6); - buf.read(foo, 6); - EXPECT_EQ(memcmp(foo, data + 2, 6), 0); - EXPECT_EQ(buf.size(), 0); -} - -// Basic single write overflow functionality -TEST(CircleBufTest, SingleWriteOverflow) -{ - CircleBuf buf(8); - char foo[16]; - - buf.write(data, 16); - EXPECT_EQ(buf.size(), 8); - buf.peek(foo, 8); - EXPECT_EQ(memcmp(data + 8, foo, 8), 0); -} - - -// Multi-write overflow functionality -TEST(CircleBufTest, MultiWriteOverflow) -{ - CircleBuf buf(8); - char foo[16]; - - // Write, no overflow, write overflow - buf.write(data, 6); - buf.write(data + 8, 6); - EXPECT_EQ(buf.size(), 8); - buf.peek(foo, 8); - EXPECT_EQ(memcmp(data + 4, foo, 2), 0); - EXPECT_EQ(memcmp(data + 8, foo + 2, 6), 0); -} - -// Pointer wrap around -TEST(CircleBufTest, PointerWrapAround) -{ - CircleBuf buf(8); - char foo[16]; - - // _start == 0, _stop = 8 - buf.write(data, 8); - // _start == 4, _stop = 8 - buf.read(foo, 4); - // _start == 4, _stop = 12 - buf.write(data + 8, 4); - EXPECT_EQ(buf.size(), 8); - // _start == 10, _stop = 12 - // Normalized: _start == 2, _stop = 4 - buf.read(foo + 4, 6); - EXPECT_EQ(buf.size(), 2); - EXPECT_EQ(memcmp(data, foo, 10), 0); - // Normalized: _start == 4, _stop = 4 - buf.read(foo + 10, 2); - EXPECT_EQ(buf.size(), 0); - EXPECT_EQ(memcmp(data, foo, 12), 0); -} diff --git a/src/base/coroutine.test.cc b/src/base/coroutine.test.cc new file mode 100644 index 000000000..655bc254a --- /dev/null +++ b/src/base/coroutine.test.cc @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2018 ARM Limited + * 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: Giacomo Travaglini + */ + +#include + +#include "base/coroutine.hh" + +using namespace m5; + +/** + * This test is checking if the Coroutine, once it yields + * back to the caller, it is still marked as not finished. + */ +TEST(Coroutine, Unfinished) +{ + auto yielding_task = + [] (Coroutine::CallerType& yield) + { + yield(); + }; + + Coroutine coro(yielding_task); + ASSERT_TRUE(coro); +} + +/** + * This test is checking the parameter passing interface of a + * coroutine which takes an integer as an argument. + * Coroutine::operator() and CallerType::get() are the tested + * APIS. + */ +TEST(Coroutine, Passing) +{ + const std::vector input{ 1, 2, 3 }; + const std::vector expected_values = input; + + auto passing_task = + [&expected_values] (Coroutine::CallerType& yield) + { + int argument; + + for (const auto expected : expected_values) { + argument = yield.get(); + ASSERT_EQ(argument, expected); + } + }; + + Coroutine coro(passing_task); + ASSERT_TRUE(coro); + + for (const auto val : input) { + coro(val); + } +} + +/** + * This test is checking the yielding interface of a coroutine + * which takes no argument and returns integers. + * Coroutine::get() and CallerType::operator() are the tested + * APIS. + */ +TEST(Coroutine, Returning) +{ + const std::vector output{ 1, 2, 3 }; + const std::vector expected_values = output; + + auto returning_task = + [&output] (Coroutine::CallerType& yield) + { + for (const auto ret : output) { + yield(ret); + } + }; + + Coroutine coro(returning_task); + ASSERT_TRUE(coro); + + for (const auto expected : expected_values) { + int returned = coro.get(); + ASSERT_EQ(returned, expected); + } +} + +/** + * This test is still supposed to test the returning interface + * of the the Coroutine, proving how coroutine can be used + * for generators. + * The coroutine is computing the first #steps of the fibonacci + * sequence and it is yielding back results one number per time. + */ +TEST(Coroutine, Fibonacci) +{ + const std::vector expected_values{ + 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 }; + + const int steps = expected_values.size(); + + auto fibonacci_task = + [steps] (Coroutine::CallerType& yield) + { + int prev = 0; + int current = 1; + + for (auto iter = 0; iter < steps; iter++) { + int sum = prev + current; + yield(sum); + + prev = current; + current = sum; + } + }; + + Coroutine coro(fibonacci_task); + ASSERT_TRUE(coro); + + for (const auto expected : expected_values) { + ASSERT_TRUE(coro); + int returned = coro.get(); + ASSERT_EQ(returned, expected); + } +} + +/** + * This test is using a bi-channel coroutine (accepting and + * yielding values) for testing a cooperative task. + * The caller and the coroutine have a string each; they are + * composing a new string by merging the strings together one + * character per time. + * The result string is hence passed back and forth between the + * coroutine and the caller. + */ +TEST(Coroutine, Cooperative) +{ + const std::string caller_str("HloWrd"); + const std::string coro_str("el ol!"); + const std::string expected("Hello World!"); + + auto cooperative_task = + [&coro_str] (Coroutine::CallerType& yield) + { + for (auto& appended_c : coro_str) { + auto old_str = yield.get(); + yield(old_str + appended_c); + } + }; + + Coroutine coro(cooperative_task); + + std::string result; + for (auto& c : caller_str) { + ASSERT_TRUE(coro); + result += c; + result = coro(result).get(); + } + + ASSERT_EQ(result, expected); +} + +/** + * This test is testing nested coroutines by using one inner and one + * outer coroutine. It basically ensures that yielding from the inner + * coroutine returns to the outer coroutine (mid-layer of execution) and + * not to the outer caller. + */ +TEST(Coroutine, Nested) +{ + const std::string wrong("Inner"); + const std::string expected("Inner + Outer"); + + auto inner_task = + [] (Coroutine::CallerType& yield) + { + std::string inner_string("Inner"); + yield(inner_string); + }; + + auto outer_task = + [&inner_task] (Coroutine::CallerType& yield) + { + Coroutine coro(inner_task); + std::string inner_string = coro.get(); + + std::string outer_string("Outer"); + yield(inner_string + " + " + outer_string); + }; + + + Coroutine coro(outer_task); + ASSERT_TRUE(coro); + + std::string result = coro.get(); + + ASSERT_NE(result, wrong); + ASSERT_EQ(result, expected); +} + +/** + * This test is stressing the scenario where two distinct fibers are + * calling the same coroutine. First the test instantiates (and runs) a + * coroutine, then spawns another one and it passes it a reference to + * the first coroutine. Once the new coroutine calls the first coroutine + * and the first coroutine yields, we are expecting execution flow to + * be yielded to the second caller (the second coroutine) and not the + * original caller (the test itself) + */ +TEST(Coroutine, TwoCallers) +{ + bool valid_return = false; + + Coroutine callee{[] + (Coroutine::CallerType& yield) + { + yield(); + yield(); + }}; + + Coroutine other_caller{[&callee, &valid_return] + (Coroutine::CallerType& yield) + { + callee(); + valid_return = true; + yield(); + }}; + + ASSERT_TRUE(valid_return); +} diff --git a/src/base/coroutinetest.cc b/src/base/coroutinetest.cc deleted file mode 100644 index 655bc254a..000000000 --- a/src/base/coroutinetest.cc +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Copyright (c) 2018 ARM Limited - * 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: Giacomo Travaglini - */ - -#include - -#include "base/coroutine.hh" - -using namespace m5; - -/** - * This test is checking if the Coroutine, once it yields - * back to the caller, it is still marked as not finished. - */ -TEST(Coroutine, Unfinished) -{ - auto yielding_task = - [] (Coroutine::CallerType& yield) - { - yield(); - }; - - Coroutine coro(yielding_task); - ASSERT_TRUE(coro); -} - -/** - * This test is checking the parameter passing interface of a - * coroutine which takes an integer as an argument. - * Coroutine::operator() and CallerType::get() are the tested - * APIS. - */ -TEST(Coroutine, Passing) -{ - const std::vector input{ 1, 2, 3 }; - const std::vector expected_values = input; - - auto passing_task = - [&expected_values] (Coroutine::CallerType& yield) - { - int argument; - - for (const auto expected : expected_values) { - argument = yield.get(); - ASSERT_EQ(argument, expected); - } - }; - - Coroutine coro(passing_task); - ASSERT_TRUE(coro); - - for (const auto val : input) { - coro(val); - } -} - -/** - * This test is checking the yielding interface of a coroutine - * which takes no argument and returns integers. - * Coroutine::get() and CallerType::operator() are the tested - * APIS. - */ -TEST(Coroutine, Returning) -{ - const std::vector output{ 1, 2, 3 }; - const std::vector expected_values = output; - - auto returning_task = - [&output] (Coroutine::CallerType& yield) - { - for (const auto ret : output) { - yield(ret); - } - }; - - Coroutine coro(returning_task); - ASSERT_TRUE(coro); - - for (const auto expected : expected_values) { - int returned = coro.get(); - ASSERT_EQ(returned, expected); - } -} - -/** - * This test is still supposed to test the returning interface - * of the the Coroutine, proving how coroutine can be used - * for generators. - * The coroutine is computing the first #steps of the fibonacci - * sequence and it is yielding back results one number per time. - */ -TEST(Coroutine, Fibonacci) -{ - const std::vector expected_values{ - 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 }; - - const int steps = expected_values.size(); - - auto fibonacci_task = - [steps] (Coroutine::CallerType& yield) - { - int prev = 0; - int current = 1; - - for (auto iter = 0; iter < steps; iter++) { - int sum = prev + current; - yield(sum); - - prev = current; - current = sum; - } - }; - - Coroutine coro(fibonacci_task); - ASSERT_TRUE(coro); - - for (const auto expected : expected_values) { - ASSERT_TRUE(coro); - int returned = coro.get(); - ASSERT_EQ(returned, expected); - } -} - -/** - * This test is using a bi-channel coroutine (accepting and - * yielding values) for testing a cooperative task. - * The caller and the coroutine have a string each; they are - * composing a new string by merging the strings together one - * character per time. - * The result string is hence passed back and forth between the - * coroutine and the caller. - */ -TEST(Coroutine, Cooperative) -{ - const std::string caller_str("HloWrd"); - const std::string coro_str("el ol!"); - const std::string expected("Hello World!"); - - auto cooperative_task = - [&coro_str] (Coroutine::CallerType& yield) - { - for (auto& appended_c : coro_str) { - auto old_str = yield.get(); - yield(old_str + appended_c); - } - }; - - Coroutine coro(cooperative_task); - - std::string result; - for (auto& c : caller_str) { - ASSERT_TRUE(coro); - result += c; - result = coro(result).get(); - } - - ASSERT_EQ(result, expected); -} - -/** - * This test is testing nested coroutines by using one inner and one - * outer coroutine. It basically ensures that yielding from the inner - * coroutine returns to the outer coroutine (mid-layer of execution) and - * not to the outer caller. - */ -TEST(Coroutine, Nested) -{ - const std::string wrong("Inner"); - const std::string expected("Inner + Outer"); - - auto inner_task = - [] (Coroutine::CallerType& yield) - { - std::string inner_string("Inner"); - yield(inner_string); - }; - - auto outer_task = - [&inner_task] (Coroutine::CallerType& yield) - { - Coroutine coro(inner_task); - std::string inner_string = coro.get(); - - std::string outer_string("Outer"); - yield(inner_string + " + " + outer_string); - }; - - - Coroutine coro(outer_task); - ASSERT_TRUE(coro); - - std::string result = coro.get(); - - ASSERT_NE(result, wrong); - ASSERT_EQ(result, expected); -} - -/** - * This test is stressing the scenario where two distinct fibers are - * calling the same coroutine. First the test instantiates (and runs) a - * coroutine, then spawns another one and it passes it a reference to - * the first coroutine. Once the new coroutine calls the first coroutine - * and the first coroutine yields, we are expecting execution flow to - * be yielded to the second caller (the second coroutine) and not the - * original caller (the test itself) - */ -TEST(Coroutine, TwoCallers) -{ - bool valid_return = false; - - Coroutine callee{[] - (Coroutine::CallerType& yield) - { - yield(); - yield(); - }}; - - Coroutine other_caller{[&callee, &valid_return] - (Coroutine::CallerType& yield) - { - callee(); - valid_return = true; - yield(); - }}; - - ASSERT_TRUE(valid_return); -} diff --git a/src/base/cprintf.test.cc b/src/base/cprintf.test.cc new file mode 100644 index 000000000..3a1b97e40 --- /dev/null +++ b/src/base/cprintf.test.cc @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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: Nathan Binkert + */ + +#include + +#include +#include +#include + +#include "base/cprintf.hh" + +#define CPRINTF_TEST(...) \ + do { \ + std::stringstream ss; \ + ccprintf(ss, __VA_ARGS__); \ + int maxlen = ss.str().length() + 3; \ + char *buf = new char[maxlen]; \ + buf[maxlen - 1] = '\0'; \ + snprintf(buf, maxlen - 2, __VA_ARGS__); \ + EXPECT_EQ(ss.str(), std::string(buf)); \ + delete [] buf; \ + } while (0) + +TEST(CPrintf, Misc) +{ + char foo[] = "foo"; + CPRINTF_TEST("%s\n", foo); + + CPRINTF_TEST("%d\n", 'A'); + CPRINTF_TEST("%shits%%s + %smisses%%s\n", "test", "test"); + CPRINTF_TEST("%%s%-10s %c he went home \'\"%d %#o %#llx %1.5f %1.2E\n", + "hello", 'A', 1, 0xff, 0xfffffffffffffULL, 3.141592653589, + 1.1e10); + + CPRINTF_TEST("another test\n"); + + CPRINTF_TEST("%-10s %c he home \'\"%d %#o %#llx %1.5f %1.2E\n", + "hello", 'A', 1, 0xff, 0xfffffffffffffULL, + 3.14159265, 1.1e10); +} + +TEST(CPrintf, FloatingPoint) +{ + double f = 314159.26535897932384; + + CPRINTF_TEST("%1.8f\n", f); + CPRINTF_TEST("%2.8f\n", f); + CPRINTF_TEST("%3.8f\n", f); + CPRINTF_TEST("%4.8f\n", f); + CPRINTF_TEST("%5.8f\n", f); + CPRINTF_TEST("%6.8f\n", f); + CPRINTF_TEST("%12.8f\n", f); + CPRINTF_TEST("%1000.8f\n", f); + CPRINTF_TEST("%1.0f\n", f); + CPRINTF_TEST("%1.1f\n", f); + CPRINTF_TEST("%1.2f\n", f); + CPRINTF_TEST("%1.3f\n", f); + CPRINTF_TEST("%1.4f\n", f); + CPRINTF_TEST("%1.5f\n", f); + CPRINTF_TEST("%1.6f\n", f); + CPRINTF_TEST("%1.7f\n", f); + CPRINTF_TEST("%1.8f\n", f); + CPRINTF_TEST("%1.9f\n", f); + CPRINTF_TEST("%1.10f\n", f); + CPRINTF_TEST("%1.11f\n", f); + CPRINTF_TEST("%1.12f\n", f); + CPRINTF_TEST("%1.13f\n", f); + CPRINTF_TEST("%1.14f\n", f); + CPRINTF_TEST("%1.15f\n", f); + CPRINTF_TEST("%1.16f\n", f); + CPRINTF_TEST("%1.17f\n", f); + CPRINTF_TEST("%1.18f\n", f); + + f = 0.00000026535897932384; + CPRINTF_TEST("%1.8f\n", f); + CPRINTF_TEST("%2.8f\n", f); + CPRINTF_TEST("%3.8f\n", f); + CPRINTF_TEST("%4.8f\n", f); + CPRINTF_TEST("%5.8f\n", f); + CPRINTF_TEST("%6.8f\n", f); + CPRINTF_TEST("%12.8f\n", f); + CPRINTF_TEST("%1.0f\n", f); + CPRINTF_TEST("%1.1f\n", f); + CPRINTF_TEST("%1.2f\n", f); + CPRINTF_TEST("%1.3f\n", f); + CPRINTF_TEST("%1.4f\n", f); + CPRINTF_TEST("%1.5f\n", f); + CPRINTF_TEST("%1.6f\n", f); + CPRINTF_TEST("%1.7f\n", f); + CPRINTF_TEST("%1.8f\n", f); + CPRINTF_TEST("%1.9f\n", f); + CPRINTF_TEST("%1.10f\n", f); + CPRINTF_TEST("%1.11f\n", f); + CPRINTF_TEST("%1.12f\n", f); + CPRINTF_TEST("%1.13f\n", f); + CPRINTF_TEST("%1.14f\n", f); + CPRINTF_TEST("%1.15f\n", f); + CPRINTF_TEST("%1.16f\n", f); + CPRINTF_TEST("%1.17f\n", f); + CPRINTF_TEST("%1.18f\n", f); + + f = 0.00000026535897932384; + CPRINTF_TEST("%1.8e\n", f); + CPRINTF_TEST("%2.8e\n", f); + CPRINTF_TEST("%3.8e\n", f); + CPRINTF_TEST("%4.8e\n", f); + CPRINTF_TEST("%5.8e\n", f); + CPRINTF_TEST("%6.8e\n", f); + CPRINTF_TEST("%12.8e\n", f); + CPRINTF_TEST("%1.0e\n", f); + CPRINTF_TEST("%1.1e\n", f); + CPRINTF_TEST("%1.2e\n", f); + CPRINTF_TEST("%1.3e\n", f); + CPRINTF_TEST("%1.4e\n", f); + CPRINTF_TEST("%1.5e\n", f); + CPRINTF_TEST("%1.6e\n", f); + CPRINTF_TEST("%1.7e\n", f); + CPRINTF_TEST("%1.8e\n", f); + CPRINTF_TEST("%1.9e\n", f); + CPRINTF_TEST("%1.10e\n", f); + CPRINTF_TEST("%1.11e\n", f); + CPRINTF_TEST("%1.12e\n", f); + CPRINTF_TEST("%1.13e\n", f); + CPRINTF_TEST("%1.14e\n", f); + CPRINTF_TEST("%1.15e\n", f); + CPRINTF_TEST("%1.16e\n", f); + CPRINTF_TEST("%1.17e\n", f); + CPRINTF_TEST("%1.18e\n", f); +} + +TEST(CPrintf, Types) +{ + std::stringstream ss; + + std::string foo1 = "string test"; + ccprintf(ss, "%s\n", foo1); + EXPECT_EQ(ss.str(), "string test\n"); + ss.str(""); + + std::stringstream foo2; + foo2 << "stringstream test"; + ccprintf(ss, "%s\n", foo2.str()); + EXPECT_EQ(ss.str(), "stringstream test\n"); + ss.str(""); + + CPRINTF_TEST("%c %c\n", 'c', 65); +} + +TEST(CPrintf, SpecialFormatting) +{ + CPRINTF_TEST("%08.4f\n", 99.99); + CPRINTF_TEST("%0*.*f\n", 8, 4, 99.99); + CPRINTF_TEST("%07.*f\n", 4, 1.234); + CPRINTF_TEST("%#0*x\n", 9, 123412); +} diff --git a/src/base/cprintftest.cc b/src/base/cprintftest.cc deleted file mode 100644 index 3a1b97e40..000000000 --- a/src/base/cprintftest.cc +++ /dev/null @@ -1,182 +0,0 @@ -/* - * Copyright (c) 2002-2005 The Regents of The University of Michigan - * All rights reserved. - * - * 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: Nathan Binkert - */ - -#include - -#include -#include -#include - -#include "base/cprintf.hh" - -#define CPRINTF_TEST(...) \ - do { \ - std::stringstream ss; \ - ccprintf(ss, __VA_ARGS__); \ - int maxlen = ss.str().length() + 3; \ - char *buf = new char[maxlen]; \ - buf[maxlen - 1] = '\0'; \ - snprintf(buf, maxlen - 2, __VA_ARGS__); \ - EXPECT_EQ(ss.str(), std::string(buf)); \ - delete [] buf; \ - } while (0) - -TEST(CPrintf, Misc) -{ - char foo[] = "foo"; - CPRINTF_TEST("%s\n", foo); - - CPRINTF_TEST("%d\n", 'A'); - CPRINTF_TEST("%shits%%s + %smisses%%s\n", "test", "test"); - CPRINTF_TEST("%%s%-10s %c he went home \'\"%d %#o %#llx %1.5f %1.2E\n", - "hello", 'A', 1, 0xff, 0xfffffffffffffULL, 3.141592653589, - 1.1e10); - - CPRINTF_TEST("another test\n"); - - CPRINTF_TEST("%-10s %c he home \'\"%d %#o %#llx %1.5f %1.2E\n", - "hello", 'A', 1, 0xff, 0xfffffffffffffULL, - 3.14159265, 1.1e10); -} - -TEST(CPrintf, FloatingPoint) -{ - double f = 314159.26535897932384; - - CPRINTF_TEST("%1.8f\n", f); - CPRINTF_TEST("%2.8f\n", f); - CPRINTF_TEST("%3.8f\n", f); - CPRINTF_TEST("%4.8f\n", f); - CPRINTF_TEST("%5.8f\n", f); - CPRINTF_TEST("%6.8f\n", f); - CPRINTF_TEST("%12.8f\n", f); - CPRINTF_TEST("%1000.8f\n", f); - CPRINTF_TEST("%1.0f\n", f); - CPRINTF_TEST("%1.1f\n", f); - CPRINTF_TEST("%1.2f\n", f); - CPRINTF_TEST("%1.3f\n", f); - CPRINTF_TEST("%1.4f\n", f); - CPRINTF_TEST("%1.5f\n", f); - CPRINTF_TEST("%1.6f\n", f); - CPRINTF_TEST("%1.7f\n", f); - CPRINTF_TEST("%1.8f\n", f); - CPRINTF_TEST("%1.9f\n", f); - CPRINTF_TEST("%1.10f\n", f); - CPRINTF_TEST("%1.11f\n", f); - CPRINTF_TEST("%1.12f\n", f); - CPRINTF_TEST("%1.13f\n", f); - CPRINTF_TEST("%1.14f\n", f); - CPRINTF_TEST("%1.15f\n", f); - CPRINTF_TEST("%1.16f\n", f); - CPRINTF_TEST("%1.17f\n", f); - CPRINTF_TEST("%1.18f\n", f); - - f = 0.00000026535897932384; - CPRINTF_TEST("%1.8f\n", f); - CPRINTF_TEST("%2.8f\n", f); - CPRINTF_TEST("%3.8f\n", f); - CPRINTF_TEST("%4.8f\n", f); - CPRINTF_TEST("%5.8f\n", f); - CPRINTF_TEST("%6.8f\n", f); - CPRINTF_TEST("%12.8f\n", f); - CPRINTF_TEST("%1.0f\n", f); - CPRINTF_TEST("%1.1f\n", f); - CPRINTF_TEST("%1.2f\n", f); - CPRINTF_TEST("%1.3f\n", f); - CPRINTF_TEST("%1.4f\n", f); - CPRINTF_TEST("%1.5f\n", f); - CPRINTF_TEST("%1.6f\n", f); - CPRINTF_TEST("%1.7f\n", f); - CPRINTF_TEST("%1.8f\n", f); - CPRINTF_TEST("%1.9f\n", f); - CPRINTF_TEST("%1.10f\n", f); - CPRINTF_TEST("%1.11f\n", f); - CPRINTF_TEST("%1.12f\n", f); - CPRINTF_TEST("%1.13f\n", f); - CPRINTF_TEST("%1.14f\n", f); - CPRINTF_TEST("%1.15f\n", f); - CPRINTF_TEST("%1.16f\n", f); - CPRINTF_TEST("%1.17f\n", f); - CPRINTF_TEST("%1.18f\n", f); - - f = 0.00000026535897932384; - CPRINTF_TEST("%1.8e\n", f); - CPRINTF_TEST("%2.8e\n", f); - CPRINTF_TEST("%3.8e\n", f); - CPRINTF_TEST("%4.8e\n", f); - CPRINTF_TEST("%5.8e\n", f); - CPRINTF_TEST("%6.8e\n", f); - CPRINTF_TEST("%12.8e\n", f); - CPRINTF_TEST("%1.0e\n", f); - CPRINTF_TEST("%1.1e\n", f); - CPRINTF_TEST("%1.2e\n", f); - CPRINTF_TEST("%1.3e\n", f); - CPRINTF_TEST("%1.4e\n", f); - CPRINTF_TEST("%1.5e\n", f); - CPRINTF_TEST("%1.6e\n", f); - CPRINTF_TEST("%1.7e\n", f); - CPRINTF_TEST("%1.8e\n", f); - CPRINTF_TEST("%1.9e\n", f); - CPRINTF_TEST("%1.10e\n", f); - CPRINTF_TEST("%1.11e\n", f); - CPRINTF_TEST("%1.12e\n", f); - CPRINTF_TEST("%1.13e\n", f); - CPRINTF_TEST("%1.14e\n", f); - CPRINTF_TEST("%1.15e\n", f); - CPRINTF_TEST("%1.16e\n", f); - CPRINTF_TEST("%1.17e\n", f); - CPRINTF_TEST("%1.18e\n", f); -} - -TEST(CPrintf, Types) -{ - std::stringstream ss; - - std::string foo1 = "string test"; - ccprintf(ss, "%s\n", foo1); - EXPECT_EQ(ss.str(), "string test\n"); - ss.str(""); - - std::stringstream foo2; - foo2 << "stringstream test"; - ccprintf(ss, "%s\n", foo2.str()); - EXPECT_EQ(ss.str(), "stringstream test\n"); - ss.str(""); - - CPRINTF_TEST("%c %c\n", 'c', 65); -} - -TEST(CPrintf, SpecialFormatting) -{ - CPRINTF_TEST("%08.4f\n", 99.99); - CPRINTF_TEST("%0*.*f\n", 8, 4, 99.99); - CPRINTF_TEST("%07.*f\n", 4, 1.234); - CPRINTF_TEST("%#0*x\n", 9, 123412); -} diff --git a/src/base/fiber.test.cc b/src/base/fiber.test.cc new file mode 100644 index 000000000..5ed13d425 --- /dev/null +++ b/src/base/fiber.test.cc @@ -0,0 +1,140 @@ +/* + * Copyright 2018 Google, Inc. + * + * 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: Gabe Black + */ + +#include + +#include +#include +#include + +#include "base/fiber.hh" + +class TestFiber : public Fiber +{ + public: + const char *name; + std::vector next; + + TestFiber(const char *name, std::initializer_list l); + + void checkExpected(); + void main(); +}; + +extern TestFiber a; +extern TestFiber b; +extern TestFiber c; + +TestFiber a("A", { &b, &a, Fiber::primaryFiber(), &b, &c }); +TestFiber b("B", { &a, &c }); +TestFiber c("C", { &a, Fiber::primaryFiber(), Fiber::primaryFiber() }); + +std::vector::iterator expectedIt; +std::vector expected({ + &a, &b, &a, &a, /* main Fiber, */ + &a, &b, &c, &a, &c, + /* main Fiber, */ &c, &c +}); + +TestFiber::TestFiber( + const char *name, std::initializer_list l) : + name(name), next(l) +{} + +void +TestFiber::checkExpected() +{ + ASSERT_NE(expectedIt, expected.end()); + TestFiber *e = *expectedIt++; + EXPECT_EQ(e, this) << "Expected " << e->name << ", got " << name; +} + +void +TestFiber::main() +{ + checkExpected(); + for (auto &n : next) { + n->run(); + checkExpected(); + } +} + +TEST(Fiber, Switching) +{ + expectedIt = expected.begin(); + + a.run(); + EXPECT_EQ(expectedIt - expected.begin(), 4); + + a.run(); + EXPECT_EQ(expectedIt - expected.begin(), 9); + + c.run(); + EXPECT_EQ(expectedIt - expected.begin(), 10); + + EXPECT_FALSE(a.finished()); + EXPECT_FALSE(b.finished()); + EXPECT_FALSE(c.finished()); + + c.run(); + EXPECT_EQ(expected.end(), expectedIt) << + "Didn't exactly use up the expected Fiber sequence"; + + EXPECT_TRUE(c.finished()); +} + +int currentIndex = 0; + +class LinkedFiber : public Fiber +{ + public: + const int index; + LinkedFiber(Fiber *link, int index) : Fiber(link), index(index) {} + + void + main() + { + EXPECT_EQ(currentIndex, index); + currentIndex++; + } +}; + +TEST(Fiber, Linked) +{ + currentIndex = 0; + + LinkedFiber lf3(Fiber::primaryFiber(), 3); + LinkedFiber lf2(&lf3, 2); + LinkedFiber lf1(&lf2, 1); + LinkedFiber lf0(&lf1, 0); + + lf0.run(); + + EXPECT_EQ(currentIndex, 4); +} diff --git a/src/base/fibertest.cc b/src/base/fibertest.cc deleted file mode 100644 index 5ed13d425..000000000 --- a/src/base/fibertest.cc +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright 2018 Google, Inc. - * - * 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: Gabe Black - */ - -#include - -#include -#include -#include - -#include "base/fiber.hh" - -class TestFiber : public Fiber -{ - public: - const char *name; - std::vector next; - - TestFiber(const char *name, std::initializer_list l); - - void checkExpected(); - void main(); -}; - -extern TestFiber a; -extern TestFiber b; -extern TestFiber c; - -TestFiber a("A", { &b, &a, Fiber::primaryFiber(), &b, &c }); -TestFiber b("B", { &a, &c }); -TestFiber c("C", { &a, Fiber::primaryFiber(), Fiber::primaryFiber() }); - -std::vector::iterator expectedIt; -std::vector expected({ - &a, &b, &a, &a, /* main Fiber, */ - &a, &b, &c, &a, &c, - /* main Fiber, */ &c, &c -}); - -TestFiber::TestFiber( - const char *name, std::initializer_list l) : - name(name), next(l) -{} - -void -TestFiber::checkExpected() -{ - ASSERT_NE(expectedIt, expected.end()); - TestFiber *e = *expectedIt++; - EXPECT_EQ(e, this) << "Expected " << e->name << ", got " << name; -} - -void -TestFiber::main() -{ - checkExpected(); - for (auto &n : next) { - n->run(); - checkExpected(); - } -} - -TEST(Fiber, Switching) -{ - expectedIt = expected.begin(); - - a.run(); - EXPECT_EQ(expectedIt - expected.begin(), 4); - - a.run(); - EXPECT_EQ(expectedIt - expected.begin(), 9); - - c.run(); - EXPECT_EQ(expectedIt - expected.begin(), 10); - - EXPECT_FALSE(a.finished()); - EXPECT_FALSE(b.finished()); - EXPECT_FALSE(c.finished()); - - c.run(); - EXPECT_EQ(expected.end(), expectedIt) << - "Didn't exactly use up the expected Fiber sequence"; - - EXPECT_TRUE(c.finished()); -} - -int currentIndex = 0; - -class LinkedFiber : public Fiber -{ - public: - const int index; - LinkedFiber(Fiber *link, int index) : Fiber(link), index(index) {} - - void - main() - { - EXPECT_EQ(currentIndex, index); - currentIndex++; - } -}; - -TEST(Fiber, Linked) -{ - currentIndex = 0; - - LinkedFiber lf3(Fiber::primaryFiber(), 3); - LinkedFiber lf2(&lf3, 2); - LinkedFiber lf1(&lf2, 1); - LinkedFiber lf0(&lf1, 0); - - lf0.run(); - - EXPECT_EQ(currentIndex, 4); -} diff --git a/src/base/inifile.test.cc b/src/base/inifile.test.cc new file mode 100644 index 000000000..4235997f7 --- /dev/null +++ b/src/base/inifile.test.cc @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2018 ARM Limited + * All rights reserved + * + * Copyright (c) 2002-2005 The Regents of The University of Michigan + * All rights reserved. + * + * 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: Nathan Binkert + * Steve Reinhardt + */ + +#include + +#include +#include +#include +#include + +#include "base/inifile.hh" + +using namespace std; + +namespace { + +std::istringstream iniFile(R"ini_file( +[General] + Test1=BARasdf + Test2=bar + +[Junk] +Test3=yo +Test4=mama + +[Foo] +Foo1=89 +Foo2=384 + +[General] +Test3=89 + +[Junk] +Test4+=mia +)ini_file"); + +}; + +TEST(Initest, MatchFound) +{ + IniFile simConfigDB; + simConfigDB.load(iniFile); + + std::string value; + + auto ret = simConfigDB.find("General", "Test2", value); + ASSERT_TRUE(ret); + ASSERT_STREQ(value.c_str(), "bar"); + + ret = simConfigDB.find("Junk", "Test3", value); + ASSERT_TRUE(ret); + ASSERT_STREQ(value.c_str(), "yo"); + + ret = simConfigDB.find("Junk", "Test4", value); + ASSERT_TRUE(ret); + ASSERT_STREQ(value.c_str(), "mama mia"); + + ret = simConfigDB.find("General", "Test1", value); + ASSERT_TRUE(ret); + ASSERT_STREQ(value.c_str(), "BARasdf"); + + ret = simConfigDB.find("General", "Test3", value); + ASSERT_TRUE(ret); + ASSERT_STREQ(value.c_str(), "89"); +} + +TEST(Initest, MatchNotFound) +{ + IniFile simConfigDB; + simConfigDB.load(iniFile); + + std::string value; + + auto ret = simConfigDB.find("Junk2", "test3", value); + ASSERT_FALSE(ret); + + ret = simConfigDB.find("Junk", "test4", value); + ASSERT_FALSE(ret); +} diff --git a/src/base/inifiletest.cc b/src/base/inifiletest.cc deleted file mode 100644 index 4235997f7..000000000 --- a/src/base/inifiletest.cc +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Copyright (c) 2018 ARM Limited - * All rights reserved - * - * Copyright (c) 2002-2005 The Regents of The University of Michigan - * All rights reserved. - * - * 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: Nathan Binkert - * Steve Reinhardt - */ - -#include - -#include -#include -#include -#include - -#include "base/inifile.hh" - -using namespace std; - -namespace { - -std::istringstream iniFile(R"ini_file( -[General] - Test1=BARasdf - Test2=bar - -[Junk] -Test3=yo -Test4=mama - -[Foo] -Foo1=89 -Foo2=384 - -[General] -Test3=89 - -[Junk] -Test4+=mia -)ini_file"); - -}; - -TEST(Initest, MatchFound) -{ - IniFile simConfigDB; - simConfigDB.load(iniFile); - - std::string value; - - auto ret = simConfigDB.find("General", "Test2", value); - ASSERT_TRUE(ret); - ASSERT_STREQ(value.c_str(), "bar"); - - ret = simConfigDB.find("Junk", "Test3", value); - ASSERT_TRUE(ret); - ASSERT_STREQ(value.c_str(), "yo"); - - ret = simConfigDB.find("Junk", "Test4", value); - ASSERT_TRUE(ret); - ASSERT_STREQ(value.c_str(), "mama mia"); - - ret = simConfigDB.find("General", "Test1", value); - ASSERT_TRUE(ret); - ASSERT_STREQ(value.c_str(), "BARasdf"); - - ret = simConfigDB.find("General", "Test3", value); - ASSERT_TRUE(ret); - ASSERT_STREQ(value.c_str(), "89"); -} - -TEST(Initest, MatchNotFound) -{ - IniFile simConfigDB; - simConfigDB.load(iniFile); - - std::string value; - - auto ret = simConfigDB.find("Junk2", "test3", value); - ASSERT_FALSE(ret); - - ret = simConfigDB.find("Junk", "test4", value); - ASSERT_FALSE(ret); -} diff --git a/src/base/pixel.test.cc b/src/base/pixel.test.cc new file mode 100644 index 000000000..4c88fc964 --- /dev/null +++ b/src/base/pixel.test.cc @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2015 ARM Limited + * 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: Andreas Sandberg + */ + +#include + +#include "base/pixel.hh" + +static Pixel pixel_red(0xff, 0x00, 0x00); +static Pixel pixel_green(0x00, 0xff, 0x00); +static Pixel pixel_blue(0x00, 0x00, 0xff); + +TEST(FBTest, PixelConversionRGBA8888) +{ + EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_red), + 0x000000ffU); + EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_green), + 0x0000ff00U); + EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_blue), + 0x00ff0000U); + + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x000000ffU), + pixel_red); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x0000ff00U), + pixel_green); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x00ff0000U), + pixel_blue); +} + +TEST(FBTest, PixelConversionRGB565) +{ + EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_red), 0x001fU); + EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_green), 0x07e0U); + EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_blue), 0xf800U); + + EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0x001fU), pixel_red); + EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0x07e0U), pixel_green); + EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0xf800U), pixel_blue); +} + +TEST(FBTest, PixelToMemRGBA8888LE) +{ + uint8_t data[] = { 0xde, 0xad, 0xbe, 0xef }; + PixelConverter::rgba8888_le.fromPixel(data, pixel_red); + EXPECT_EQ(data[0], 0xff); + EXPECT_EQ(data[1], 0x00); + EXPECT_EQ(data[3], 0x00); + EXPECT_EQ(data[3], 0x00); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_red); + + PixelConverter::rgba8888_le.fromPixel(data, pixel_green); + EXPECT_EQ(data[0], 0x00); + EXPECT_EQ(data[1], 0xff); + EXPECT_EQ(data[3], 0x00); + EXPECT_EQ(data[3], 0x00); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_green); + + PixelConverter::rgba8888_le.fromPixel(data, pixel_blue); + EXPECT_EQ(data[0], 0x00); + EXPECT_EQ(data[1], 0x00); + EXPECT_EQ(data[2], 0xff); + EXPECT_EQ(data[3], 0x00); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_blue); +} + +TEST(FBTest, MemToPixelRGBA8888LE) +{ + uint8_t red[] = { 0xff, 0x00, 0x00, 0x00 }; + uint8_t green[] = { 0x00, 0xff, 0x00, 0x00 }; + uint8_t blue[] = { 0x00, 0x00, 0xff, 0x00 }; + + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(red), pixel_red); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(green), pixel_green); + EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(blue), pixel_blue); +} + +TEST(FBTest, MemToPixelRGBA8888BE) +{ + uint8_t red[] = { 0x00, 0x00, 0x00, 0xff }; + uint8_t green[] = { 0x00, 0x00, 0xff, 0x00 }; + uint8_t blue[] = { 0x00, 0xff, 0x00, 0x00 }; + + EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(red), pixel_red); + EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(green), pixel_green); + EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(blue), pixel_blue); +} diff --git a/src/base/pixeltest.cc b/src/base/pixeltest.cc deleted file mode 100644 index 4c88fc964..000000000 --- a/src/base/pixeltest.cc +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright (c) 2015 ARM Limited - * 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: Andreas Sandberg - */ - -#include - -#include "base/pixel.hh" - -static Pixel pixel_red(0xff, 0x00, 0x00); -static Pixel pixel_green(0x00, 0xff, 0x00); -static Pixel pixel_blue(0x00, 0x00, 0xff); - -TEST(FBTest, PixelConversionRGBA8888) -{ - EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_red), - 0x000000ffU); - EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_green), - 0x0000ff00U); - EXPECT_EQ(PixelConverter::rgba8888_le.fromPixel(pixel_blue), - 0x00ff0000U); - - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x000000ffU), - pixel_red); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x0000ff00U), - pixel_green); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(0x00ff0000U), - pixel_blue); -} - -TEST(FBTest, PixelConversionRGB565) -{ - EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_red), 0x001fU); - EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_green), 0x07e0U); - EXPECT_EQ(PixelConverter::rgb565_le.fromPixel(pixel_blue), 0xf800U); - - EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0x001fU), pixel_red); - EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0x07e0U), pixel_green); - EXPECT_EQ(PixelConverter::rgb565_le.toPixel(0xf800U), pixel_blue); -} - -TEST(FBTest, PixelToMemRGBA8888LE) -{ - uint8_t data[] = { 0xde, 0xad, 0xbe, 0xef }; - PixelConverter::rgba8888_le.fromPixel(data, pixel_red); - EXPECT_EQ(data[0], 0xff); - EXPECT_EQ(data[1], 0x00); - EXPECT_EQ(data[3], 0x00); - EXPECT_EQ(data[3], 0x00); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_red); - - PixelConverter::rgba8888_le.fromPixel(data, pixel_green); - EXPECT_EQ(data[0], 0x00); - EXPECT_EQ(data[1], 0xff); - EXPECT_EQ(data[3], 0x00); - EXPECT_EQ(data[3], 0x00); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_green); - - PixelConverter::rgba8888_le.fromPixel(data, pixel_blue); - EXPECT_EQ(data[0], 0x00); - EXPECT_EQ(data[1], 0x00); - EXPECT_EQ(data[2], 0xff); - EXPECT_EQ(data[3], 0x00); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(data), pixel_blue); -} - -TEST(FBTest, MemToPixelRGBA8888LE) -{ - uint8_t red[] = { 0xff, 0x00, 0x00, 0x00 }; - uint8_t green[] = { 0x00, 0xff, 0x00, 0x00 }; - uint8_t blue[] = { 0x00, 0x00, 0xff, 0x00 }; - - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(red), pixel_red); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(green), pixel_green); - EXPECT_EQ(PixelConverter::rgba8888_le.toPixel(blue), pixel_blue); -} - -TEST(FBTest, MemToPixelRGBA8888BE) -{ - uint8_t red[] = { 0x00, 0x00, 0x00, 0xff }; - uint8_t green[] = { 0x00, 0x00, 0xff, 0x00 }; - uint8_t blue[] = { 0x00, 0xff, 0x00, 0x00 }; - - EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(red), pixel_red); - EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(green), pixel_green); - EXPECT_EQ(PixelConverter::rgba8888_be.toPixel(blue), pixel_blue); -} diff --git a/src/base/trie.test.cc b/src/base/trie.test.cc new file mode 100644 index 000000000..154200973 --- /dev/null +++ b/src/base/trie.test.cc @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2012 Google + * All rights reserved. + * + * 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: Gabe Black + */ + +#include + +#include +#include +#include + +#include "base/trie.hh" +#include "base/types.hh" + +namespace { + +static inline uint32_t *ptr(uintptr_t val) +{ + return (uint32_t *)val; +} + +} // anonymous namespace + +class TrieTestData : public testing::Test +{ + protected: + typedef Trie TrieType; + TrieType trie; + + std::string + dumpTrie() + { + std::stringstream ss; + trie.dump("test trie", ss); + return ss.str(); + } +}; + +TEST_F(TrieTestData, Empty) +{ + EXPECT_EQ(trie.lookup(0x123456701234567), nullptr) << dumpTrie(); +} + +TEST_F(TrieTestData, SingleEntry) +{ + trie.insert(0x0123456789abcdef, 40, ptr(1)); + EXPECT_EQ(trie.lookup(0x123456701234567), nullptr) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(1)) << dumpTrie(); +} + +TEST_F(TrieTestData, TwoOverlappingEntries) +{ + trie.insert(0x0123456789abcdef, 40, ptr(1)); + trie.insert(0x0123456789abcdef, 36, ptr(2)); + EXPECT_EQ(trie.lookup(0x123456700000000), nullptr) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(2)) << dumpTrie(); +} + +TEST_F(TrieTestData, TwoOverlappingEntriesReversed) +{ + trie.insert(0x0123456789abcdef, 36, ptr(2)); + trie.insert(0x0123456789abcdef, 40, ptr(1)); + EXPECT_EQ(trie.lookup(0x123456700000000), nullptr) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(2)) << dumpTrie(); +} + +TEST_F(TrieTestData, TwoIndependentEntries) +{ + trie.insert(0x0123456789abcdef, 40, ptr(2)); + trie.insert(0x0123456776543210, 40, ptr(1)); + EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(2)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456776000000), ptr(1)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456700000000), nullptr) << dumpTrie(); +} + +TEST_F(TrieTestData, TwoEntries) +{ + trie.insert(0x0123456789000000, 40, ptr(4)); + trie.insert(0x0123000000000000, 40, ptr(1)); + trie.insert(0x0123456780000000, 40, ptr(3)); + trie.insert(0x0123456700000000, 40, ptr(2)); + + EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(2)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); +} + +TEST_F(TrieTestData, RemovingEntries) +{ + TrieType::Handle node1, node2; + trie.insert(0x0123456789000000, 40, ptr(4)); + trie.insert(0x0123000000000000, 40, ptr(1)); + trie.insert(0x0123456780000000, 40, ptr(3)); + node1 = trie.insert(0x0123456700000000, 40, ptr(2)); + node2 = trie.insert(0x0123456700000000, 32, ptr(10)); + + EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(10)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(10)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(10)) << dumpTrie(); + + trie.remove(node2); + + EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(2)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); + + trie.remove(node1); + + EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456700000000), nullptr) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); + EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); +} diff --git a/src/base/trietest.cc b/src/base/trietest.cc deleted file mode 100644 index 154200973..000000000 --- a/src/base/trietest.cc +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright (c) 2012 Google - * All rights reserved. - * - * 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: Gabe Black - */ - -#include - -#include -#include -#include - -#include "base/trie.hh" -#include "base/types.hh" - -namespace { - -static inline uint32_t *ptr(uintptr_t val) -{ - return (uint32_t *)val; -} - -} // anonymous namespace - -class TrieTestData : public testing::Test -{ - protected: - typedef Trie TrieType; - TrieType trie; - - std::string - dumpTrie() - { - std::stringstream ss; - trie.dump("test trie", ss); - return ss.str(); - } -}; - -TEST_F(TrieTestData, Empty) -{ - EXPECT_EQ(trie.lookup(0x123456701234567), nullptr) << dumpTrie(); -} - -TEST_F(TrieTestData, SingleEntry) -{ - trie.insert(0x0123456789abcdef, 40, ptr(1)); - EXPECT_EQ(trie.lookup(0x123456701234567), nullptr) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(1)) << dumpTrie(); -} - -TEST_F(TrieTestData, TwoOverlappingEntries) -{ - trie.insert(0x0123456789abcdef, 40, ptr(1)); - trie.insert(0x0123456789abcdef, 36, ptr(2)); - EXPECT_EQ(trie.lookup(0x123456700000000), nullptr) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(2)) << dumpTrie(); -} - -TEST_F(TrieTestData, TwoOverlappingEntriesReversed) -{ - trie.insert(0x0123456789abcdef, 36, ptr(2)); - trie.insert(0x0123456789abcdef, 40, ptr(1)); - EXPECT_EQ(trie.lookup(0x123456700000000), nullptr) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x123456789ab0000), ptr(2)) << dumpTrie(); -} - -TEST_F(TrieTestData, TwoIndependentEntries) -{ - trie.insert(0x0123456789abcdef, 40, ptr(2)); - trie.insert(0x0123456776543210, 40, ptr(1)); - EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(2)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456776000000), ptr(1)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456700000000), nullptr) << dumpTrie(); -} - -TEST_F(TrieTestData, TwoEntries) -{ - trie.insert(0x0123456789000000, 40, ptr(4)); - trie.insert(0x0123000000000000, 40, ptr(1)); - trie.insert(0x0123456780000000, 40, ptr(3)); - trie.insert(0x0123456700000000, 40, ptr(2)); - - EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(2)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); -} - -TEST_F(TrieTestData, RemovingEntries) -{ - TrieType::Handle node1, node2; - trie.insert(0x0123456789000000, 40, ptr(4)); - trie.insert(0x0123000000000000, 40, ptr(1)); - trie.insert(0x0123456780000000, 40, ptr(3)); - node1 = trie.insert(0x0123456700000000, 40, ptr(2)); - node2 = trie.insert(0x0123456700000000, 32, ptr(10)); - - EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(10)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(10)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(10)) << dumpTrie(); - - trie.remove(node2); - - EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456700000000), ptr(2)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); - - trie.remove(node1); - - EXPECT_EQ(trie.lookup(0x0123000000000000), ptr(1)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456700000000), nullptr) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456780000000), ptr(3)) << dumpTrie(); - EXPECT_EQ(trie.lookup(0x0123456789000000), ptr(4)) << dumpTrie(); -}