archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-22 12:04:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8168493: Convert TestBitMap_test to GTest

Browse source 
Reviewed-by: kbarrett, tschatzl
This commit is contained in:
Kirill Zhaldybin 2016-11-01 16:23:29 +03:00
parent 95a418feb0
commit db6e54d852
4 changed files with 132 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

114
hotspot/src/share/vm/utilities/bitMap.cpp
View file

@ -680,118 +680,4 @@ void BitMap::print_on(outputStream* st) const {
tty->cr();
}
class TestBitMap : public AllStatic {
const static BitMap::idx_t BITMAP_SIZE = 1024;
template <class ResizableBitMapClass>
static void fillBitMap(ResizableBitMapClass& map) {
map.set_bit(1);
map.set_bit(3);
map.set_bit(17);
map.set_bit(512);
}
template <class ResizableBitMapClass>
static void testResize(BitMap::idx_t start_size) {
ResourceMark rm;
ResizableBitMapClass map(start_size);
map.resize(BITMAP_SIZE);
fillBitMap(map);
ResizableBitMapClass map2(BITMAP_SIZE);
fillBitMap(map2);
assert(map.is_same(map2), "could be");
}
template <class ResizableBitMapClass>
static void testResizeGrow() {
testResize<ResizableBitMapClass>(0);
testResize<ResizableBitMapClass>(128);
}
template <class ResizableBitMapClass>
static void testResizeSame() {
testResize<ResizableBitMapClass>(BITMAP_SIZE);
}
template <class ResizableBitMapClass>
static void testResizeShrink() {
testResize<ResizableBitMapClass>(BITMAP_SIZE * 2);
}
static void testResizeGrow() {
testResizeGrow<ResourceBitMap>();
testResizeGrow<CHeapBitMap>();
}
static void testResizeSame() {
testResizeSame<ResourceBitMap>();
testResizeSame<CHeapBitMap>();
}
static void testResizeShrink() {
testResizeShrink<ResourceBitMap>();
testResizeShrink<CHeapBitMap>();
}
static void testResize() {
testResizeGrow();
testResizeSame();
testResizeShrink();
}
template <class InitializableBitMapClass>
static void testInitialize() {
ResourceMark rm;
InitializableBitMapClass map;
map.initialize(BITMAP_SIZE);
fillBitMap(map);
InitializableBitMapClass map2(BITMAP_SIZE);
fillBitMap(map2);
assert(map.is_same(map2), "could be");
}
static void testInitialize() {
testInitialize<ResourceBitMap>();
testInitialize<CHeapBitMap>();
}
template <class ReinitializableBitMapClass>
static void testReinitialize(BitMap::idx_t init_size) {
ResourceMark rm;
ReinitializableBitMapClass map(init_size);
map.reinitialize(BITMAP_SIZE);
fillBitMap(map);
ReinitializableBitMapClass map2(BITMAP_SIZE);
fillBitMap(map2);
assert(map.is_same(map2), "could be");
}
template <class ReinitializableBitMapClass>
static void testReinitialize() {
testReinitialize<ReinitializableBitMapClass>(0);
testReinitialize<ReinitializableBitMapClass>(128);
testReinitialize<ReinitializableBitMapClass>(BITMAP_SIZE);
}
static void testReinitialize() {
testReinitialize<ResourceBitMap>();
}
public:
static void test() {
testResize();
testInitialize();
testReinitialize();
}
};
void TestBitMap_test() {
TestBitMap::test();
}
#endif

2
hotspot/src/share/vm/utilities/bitMap.hpp
View file

@ -312,7 +312,6 @@ class BitMapView : public BitMap {
// A BitMap with storage in a ResourceArea.
class ResourceBitMap : public BitMap {
friend class TestBitMap;
public:
ResourceBitMap() : BitMap(NULL, 0) {}
@ -351,7 +350,6 @@ class ArenaBitMap : public BitMap {
// A BitMap with storage in the CHeap.
class CHeapBitMap : public BitMap {
friend class TestBitMap;
private:
// Don't allow copy or assignment, to prevent the

1
hotspot/src/share/vm/utilities/internalVMTests.cpp
View file

@ -50,7 +50,6 @@ void InternalVMTests::run() {
run_unit_test(TestGlobalDefinitions_test);
run_unit_test(GCTimer_test);
run_unit_test(CollectedHeap_test);
run_unit_test(TestBitMap_test);
run_unit_test(ObjectMonitor_test);
run_unit_test(DirectivesParser_test);
#if INCLUDE_VM_STRUCTS

132
hotspot/test/native/utilities/test_bitMap.cpp Normal file
View file

@ -0,0 +1,132 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "precompiled.hpp"
#include "memory/resourceArea.hpp"
#include "utilities/bitMap.inline.hpp"
#include "unittest.hpp"
class BitMapTest {
template <class ResizableBitMapClass>
static void fillBitMap(ResizableBitMapClass& map) {
map.set_bit(1);
map.set_bit(3);
map.set_bit(17);
map.set_bit(512);
}
template <class ResizableBitMapClass>
static void testResize(BitMap::idx_t start_size) {
ResourceMark rm;
ResizableBitMapClass map(start_size);
map.resize(BITMAP_SIZE);
fillBitMap(map);
ResizableBitMapClass map2(BITMAP_SIZE);
fillBitMap(map2);
EXPECT_TRUE(map.is_same(map2)) << "With start_size " << start_size;
}
public:
const static BitMap::idx_t BITMAP_SIZE = 1024;
template <class ResizableBitMapClass>
static void testResizeGrow() {
testResize<ResizableBitMapClass>(0);
testResize<ResizableBitMapClass>(BITMAP_SIZE >> 3);
}
template <class ResizableBitMapClass>
static void testResizeSame() {
testResize<ResizableBitMapClass>(BITMAP_SIZE);
}
template <class ResizableBitMapClass>
static void testResizeShrink() {
testResize<ResizableBitMapClass>(BITMAP_SIZE * 2);
}
template <class InitializableBitMapClass>
static void testInitialize() {
ResourceMark rm;
InitializableBitMapClass map;
map.initialize(BITMAP_SIZE);
fillBitMap(map);
InitializableBitMapClass map2(BITMAP_SIZE);
fillBitMap(map2);
EXPECT_TRUE(map.is_same(map2));
}
static void testReinitialize(BitMap::idx_t init_size) {
ResourceMark rm;
ResourceBitMap map(init_size);
map.reinitialize(BITMAP_SIZE);
fillBitMap(map);
ResourceBitMap map2(BITMAP_SIZE);
fillBitMap(map2);
EXPECT_TRUE(map.is_same(map2)) << "With init_size " << init_size;
}
};
TEST_VM(BitMap, resize_grow) {
BitMapTest::testResizeGrow<ResourceBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type ResourceBitMap";
BitMapTest::testResizeGrow<CHeapBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type CHeapBitMap";
}
TEST_VM(BitMap, resize_shrink) {
BitMapTest::testResizeShrink<ResourceBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type ResourceBitMap";
BitMapTest::testResizeShrink<CHeapBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type CHeapBitMap";
}
TEST_VM(BitMap, resize_same) {
BitMapTest::testResizeSame<ResourceBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type ResourceBitMap";
BitMapTest::testResizeSame<CHeapBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type CHeapBitMap";
}
TEST_VM(BitMap, initialize) {
BitMapTest::testInitialize<ResourceBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type ResourceBitMap";
BitMapTest::testInitialize<CHeapBitMap>();
EXPECT_FALSE(HasFailure()) << "Failed on type CHeapBitMap";
}
TEST_VM(BitMap, reinitialize) {
BitMapTest::testReinitialize(0);
BitMapTest::testReinitialize(BitMapTest::BITMAP_SIZE >> 3);
BitMapTest::testReinitialize(BitMapTest::BITMAP_SIZE);
}