Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
test/hotspot/gtest/gc/shared/test_oopStorage.cpp
changeset 48806 51fc22e5fb00
parent 48787 7638bf98a312
child 48816 3495d6050efe
equal deleted inserted replaced
48805:decc1bb41107 48806:51fc22e5fb00 
    99 //     an opto namespace.
 
    99 //     an opto namespace.
 
   100 typedef TestAccess::Block OopBlock;
 
   100 typedef TestAccess::Block OopBlock;
 
   101 // --- FIXME: Similarly, this typedef collides with opto BlockList.
 
   101 // --- FIXME: Similarly, this typedef collides with opto BlockList.
 
   102 // typedef TestAccess::BlockList BlockList;
 
   102 // typedef TestAccess::BlockList BlockList;
 
   103 
   103 
       
   104 // Using EXPECT_EQ can't use NULL directly. Otherwise AIX build breaks.
 
       
   105 const OopBlock* const NULL_BLOCK = NULL;
 
       
   106 
   104 static size_t list_length(const TestAccess::BlockList& list) {
 
   107 static size_t list_length(const TestAccess::BlockList& list) {
 
   105   size_t result = 0;
 
   108   size_t result = 0;
 
   106   for (const OopBlock* block = list.chead();
 
   109   for (const OopBlock* block = list.chead();
 
   107        block != NULL;
 
   110        block != NULL;
 
   108        block = list.next(*block)) {
 
   111        block = list.next(*block)) {
 
  1194 
  1197 
  1195 TEST_F(OopStorageBlockListTest, empty_list) {
 
  1198 TEST_F(OopStorageBlockListTest, empty_list) {
 
  1196   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1199   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1197 
  1200 
  1198   EXPECT_TRUE(is_list_empty(list));
 
  1201   EXPECT_TRUE(is_list_empty(list));
 
  1199   EXPECT_EQ(NULL, list.head());
 
  1202   EXPECT_EQ(NULL_BLOCK, list.head());
 
  1200   EXPECT_EQ(NULL, list.chead());
 
  1203   EXPECT_EQ(NULL_BLOCK, list.chead());
 
  1201   EXPECT_EQ(NULL, list.ctail());
 
  1204   EXPECT_EQ(NULL_BLOCK, list.ctail());
 
  1202 }
 
  1205 }
 
  1203 
  1206 
  1204 TEST_F(OopStorageBlockListTest, push_back) {
 
  1207 TEST_F(OopStorageBlockListTest, push_back) {
 
  1205   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1208   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1206 
  1209 
  1217   const OopBlock* block = list.chead();
 
  1220   const OopBlock* block = list.chead();
 
  1218   for (size_t i = 0; i < nvalues; ++i) {
 
  1221   for (size_t i = 0; i < nvalues; ++i) {
 
  1219     EXPECT_EQ(block, values[i]);
 
  1222     EXPECT_EQ(block, values[i]);
 
  1220     block = list.next(*block);
 
  1223     block = list.next(*block);
 
  1221   }
 
  1224   }
 
  1222   EXPECT_EQ(NULL, block);
 
  1225   EXPECT_EQ(NULL_BLOCK, block);
 
  1223 
  1226 
  1224   block = list.ctail();
 
  1227   block = list.ctail();
 
  1225   for (size_t i = 0; i < nvalues; ++i) {
 
  1228   for (size_t i = 0; i < nvalues; ++i) {
 
  1226     EXPECT_EQ(block, values[nvalues - i - 1]);
 
  1229     EXPECT_EQ(block, values[nvalues - i - 1]);
 
  1227     block = list.prev(*block);
 
  1230     block = list.prev(*block);
 
  1228   }
 
  1231   }
 
  1229   EXPECT_EQ(NULL, block);
 
  1232   EXPECT_EQ(NULL_BLOCK, block);
 
  1230 
  1233 
  1231   clear_list(list);
 
  1234   clear_list(list);
 
  1232 }
 
  1235 }
 
  1233 
  1236 
  1234 TEST_F(OopStorageBlockListTest, push_front) {
 
  1237 TEST_F(OopStorageBlockListTest, push_front) {
 
  1247   const OopBlock* block = list.chead();
 
  1250   const OopBlock* block = list.chead();
 
  1248   for (size_t i = 0; i < nvalues; ++i) {
 
  1251   for (size_t i = 0; i < nvalues; ++i) {
 
  1249     EXPECT_EQ(block, values[nvalues - i - 1]);
 
  1252     EXPECT_EQ(block, values[nvalues - i - 1]);
 
  1250     block = list.next(*block);
 
  1253     block = list.next(*block);
 
  1251   }
 
  1254   }
 
  1252   EXPECT_EQ(NULL, block);
 
  1255   EXPECT_EQ(NULL_BLOCK, block);
 
  1253 
  1256 
  1254   block = list.ctail();
 
  1257   block = list.ctail();
 
  1255   for (size_t i = 0; i < nvalues; ++i) {
 
  1258   for (size_t i = 0; i < nvalues; ++i) {
 
  1256     EXPECT_EQ(block, values[i]);
 
  1259     EXPECT_EQ(block, values[i]);
 
  1257     block = list.prev(*block);
 
  1260     block = list.prev(*block);
 
  1258   }
 
  1261   }
 
  1259   EXPECT_EQ(NULL, block);
 
  1262   EXPECT_EQ(NULL_BLOCK, block);
 
  1260 
  1263 
  1261   clear_list(list);
 
  1264   clear_list(list);
 
  1262 }
 
  1265 }
 
  1263 
  1266 
  1264 class OopStorageBlockListTestWithList : public OopStorageBlockListTest {
 
  1267 class OopStorageBlockListTestWithList : public OopStorageBlockListTest {
 
  1279 TEST_F(OopStorageBlockListTestWithList, unlink_front) {
 
  1282 TEST_F(OopStorageBlockListTestWithList, unlink_front) {
 
  1280   EXPECT_EQ(list.chead(), values[0]);
 
  1283   EXPECT_EQ(list.chead(), values[0]);
 
  1281   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1284   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1282 
  1285 
  1283   list.unlink(*values[0]);
 
  1286   list.unlink(*values[0]);
 
  1284   EXPECT_EQ(NULL, list.next(*values[0]));
 
  1287   EXPECT_EQ(NULL_BLOCK, list.next(*values[0]));
 
  1285   EXPECT_EQ(NULL, list.prev(*values[0]));
 
  1288   EXPECT_EQ(NULL_BLOCK, list.prev(*values[0]));
 
  1286   EXPECT_EQ(list.chead(), values[1]);
 
  1289   EXPECT_EQ(list.chead(), values[1]);
 
  1287   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1290   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1288 
  1291 
  1289   const OopBlock* block = list.chead();
 
  1292   const OopBlock* block = list.chead();
 
  1290   for (size_t i = 1; i < nvalues; ++i) {
 
  1293   for (size_t i = 1; i < nvalues; ++i) {
 
  1291     EXPECT_EQ(block, values[i]);
 
  1294     EXPECT_EQ(block, values[i]);
 
  1292     block = list.next(*block);
 
  1295     block = list.next(*block);
 
  1293   }
 
  1296   }
 
  1294   EXPECT_EQ(NULL, block);
 
  1297   EXPECT_EQ(NULL_BLOCK, block);
 
  1295 }
 
  1298 }
 
  1296 
  1299 
  1297 TEST_F(OopStorageBlockListTestWithList, unlink_back) {
 
  1300 TEST_F(OopStorageBlockListTestWithList, unlink_back) {
 
  1298   EXPECT_EQ(list.chead(), values[0]);
 
  1301   EXPECT_EQ(list.chead(), values[0]);
 
  1299 
  1302 
  1300   list.unlink(*values[nvalues - 1]);
 
  1303   list.unlink(*values[nvalues - 1]);
 
  1301   EXPECT_EQ(NULL, list.next(*values[nvalues - 1]));
 
  1304   EXPECT_EQ(NULL_BLOCK, list.next(*values[nvalues - 1]));
 
  1302   EXPECT_EQ(NULL, list.prev(*values[nvalues - 1]));
 
  1305   EXPECT_EQ(NULL_BLOCK, list.prev(*values[nvalues - 1]));
 
  1303   EXPECT_EQ(list.chead(), values[0]);
 
  1306   EXPECT_EQ(list.chead(), values[0]);
 
  1304   EXPECT_EQ(list.ctail(), values[nvalues - 2]);
 
  1307   EXPECT_EQ(list.ctail(), values[nvalues - 2]);
 
  1305 
  1308 
  1306   const OopBlock* block = list.chead();
 
  1309   const OopBlock* block = list.chead();
 
  1307   for (size_t i = 0; i < nvalues - 1; ++i) {
 
  1310   for (size_t i = 0; i < nvalues - 1; ++i) {
 
  1308     EXPECT_EQ(block, values[i]);
 
  1311     EXPECT_EQ(block, values[i]);
 
  1309     block = list.next(*block);
 
  1312     block = list.next(*block);
 
  1310   }
 
  1313   }
 
  1311   EXPECT_EQ(NULL, block);
 
  1314   EXPECT_EQ(NULL_BLOCK, block);
 
  1312 }
 
  1315 }
 
  1313 
  1316 
  1314 TEST_F(OopStorageBlockListTestWithList, unlink_middle) {
 
  1317 TEST_F(OopStorageBlockListTestWithList, unlink_middle) {
 
  1315   EXPECT_EQ(list.chead(), values[0]);
 
  1318   EXPECT_EQ(list.chead(), values[0]);
 
  1316 
  1319 
  1317   size_t index = nvalues / 2;
 
  1320   size_t index = nvalues / 2;
 
  1318 
  1321 
  1319   list.unlink(*values[index]);
 
  1322   list.unlink(*values[index]);
 
  1320   EXPECT_EQ(NULL, list.next(*values[index]));
 
  1323   EXPECT_EQ(NULL_BLOCK, list.next(*values[index]));
 
  1321   EXPECT_EQ(NULL, list.prev(*values[index]));
 
  1324   EXPECT_EQ(NULL_BLOCK, list.prev(*values[index]));
 
  1322   EXPECT_EQ(list.chead(), values[0]);
 
  1325   EXPECT_EQ(list.chead(), values[0]);
 
  1323   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1326   EXPECT_EQ(list.ctail(), values[nvalues - 1]);
 
  1324 
  1327 
  1325   const OopBlock* block = list.chead();
 
  1328   const OopBlock* block = list.chead();
 
  1326   for (size_t i = 0; i < index; ++i) {
 
  1329   for (size_t i = 0; i < index; ++i) {
 
  1329   }
 
  1332   }
 
  1330   for (size_t i = index + 1; i < nvalues; ++i) {
 
  1333   for (size_t i = index + 1; i < nvalues; ++i) {
 
  1331     EXPECT_EQ(block, values[i]);
 
  1334     EXPECT_EQ(block, values[i]);
 
  1332     block = list.next(*block);
 
  1335     block = list.next(*block);
 
  1333   }
 
  1336   }
 
  1334   EXPECT_EQ(NULL, block);
 
  1337   EXPECT_EQ(NULL_BLOCK, block);
 
  1335 }
 
  1338 }
 
  1336 
  1339 
  1337 TEST_F(OopStorageBlockListTest, single) {
 
  1340 TEST_F(OopStorageBlockListTest, single) {
 
  1338   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1341   TestAccess::BlockList list(&OopBlock::get_active_entry);
 
  1339 
  1342 
  1340   list.push_back(*values[0]);
 
  1343   list.push_back(*values[0]);
 
  1341   EXPECT_EQ(NULL, list.next(*values[0]));
 
  1344   EXPECT_EQ(NULL_BLOCK, list.next(*values[0]));
 
  1342   EXPECT_EQ(NULL, list.prev(*values[0]));
 
  1345   EXPECT_EQ(NULL_BLOCK, list.prev(*values[0]));
 
  1343   EXPECT_EQ(list.chead(), values[0]);
 
  1346   EXPECT_EQ(list.chead(), values[0]);
 
  1344   EXPECT_EQ(list.ctail(), values[0]);
 
  1347   EXPECT_EQ(list.ctail(), values[0]);
 
  1345 
  1348 
  1346   list.unlink(*values[0]);
 
  1349   list.unlink(*values[0]);
 
  1347   EXPECT_EQ(NULL, list.next(*values[0]));
 
  1350   EXPECT_EQ(NULL_BLOCK, list.next(*values[0]));
 
  1348   EXPECT_EQ(NULL, list.prev(*values[0]));
 
  1351   EXPECT_EQ(NULL_BLOCK, list.prev(*values[0]));
 
  1349   EXPECT_EQ(NULL, list.chead());
 
  1352   EXPECT_EQ(NULL_BLOCK, list.chead());
 
  1350   EXPECT_EQ(NULL, list.ctail());
 
  1353   EXPECT_EQ(NULL_BLOCK, list.ctail());
 
  1351 }
 
  1354 }
 
  1352 
  1355 
  1353 TEST_F(OopStorageBlockListTestWithList, two_lists) {
 
  1356 TEST_F(OopStorageBlockListTestWithList, two_lists) {
 
  1354   TestAccess::BlockList list2(&OopBlock::get_allocate_entry);
 
  1357   TestAccess::BlockList list2(&OopBlock::get_allocate_entry);
 
  1355   for (size_t i = 0; i < nvalues; ++i) {
 
  1358   for (size_t i = 0; i < nvalues; ++i) {
 
  1361   for (size_t i = 0; i < nvalues; ++i) {
 
  1364   for (size_t i = 0; i < nvalues; ++i) {
 
  1362     EXPECT_EQ(active_block, allocate_block);
 
  1365     EXPECT_EQ(active_block, allocate_block);
 
  1363     active_block = list.next(*active_block);
 
  1366     active_block = list.next(*active_block);
 
  1364     allocate_block = list2.prev(*allocate_block);
 
  1367     allocate_block = list2.prev(*allocate_block);
 
  1365   }
 
  1368   }
 
  1366   EXPECT_EQ(NULL, active_block);
 
  1369   EXPECT_EQ(NULL_BLOCK, active_block);
 
  1367   EXPECT_EQ(NULL, allocate_block);
 
  1370   EXPECT_EQ(NULL_BLOCK, allocate_block);
 
  1368 
  1371 
  1369   for (size_t i = 0; i < nvalues; ++i) {
 
  1372   for (size_t i = 0; i < nvalues; ++i) {
 
  1370     list2.unlink(*values[i]);
 
  1373     list2.unlink(*values[i]);
 
  1371   }
 
  1374   }
 
  1372   EXPECT_TRUE(is_list_empty(list2));
 
  1375   EXPECT_TRUE(is_list_empty(list2));
 
  1374   active_block = list.chead();
 
  1377   active_block = list.chead();
 
  1375   for (size_t i = 0; i < nvalues; ++i) {
 
  1378   for (size_t i = 0; i < nvalues; ++i) {
 
  1376     EXPECT_EQ(active_block, values[i]);
 
  1379     EXPECT_EQ(active_block, values[i]);
 
  1377     active_block = list.next(*active_block);
 
  1380     active_block = list.next(*active_block);
 
  1378   }
 
  1381   }
 
  1379   EXPECT_EQ(NULL, active_block);
 
  1382   EXPECT_EQ(NULL_BLOCK, active_block);
 
  1380 }
 
  1383 }
 
  1381 
  1384
jdk-sandbox