blob: 16fc4c8e62b391da89fc96bfd2a65dba0f84f6f5 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "LinkedHashMapTest.h"
#include <decaf/util/Set.h>
#include <decaf/util/Iterator.h>
#include <decaf/util/LinkedHashMap.h>
#include <decaf/util/StlMap.h>
#include <decaf/util/ArrayList.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/exceptions/IllegalArgumentException.h>
using namespace std;
using namespace decaf;
using namespace decaf::util;
using namespace decaf::lang;
using namespace decaf::lang::exceptions;
////////////////////////////////////////////////////////////////////////////////
namespace {
const int MAP_SIZE = 1000;
void populateMap(LinkedHashMap<int, std::string>& map) {
for (int i = 0; i < MAP_SIZE; ++i) {
map.put(i, Integer::toString(i));
}
}
void populateMap(LinkedHashMap<int, std::string>& map, int num) {
for (int i = 0; i < num; ++i) {
map.put(i, Integer::toString(i));
}
}
}
////////////////////////////////////////////////////////////////////////////////
LinkedHashMapTest::LinkedHashMapTest() {
}
////////////////////////////////////////////////////////////////////////////////
LinkedHashMapTest::~LinkedHashMapTest() {
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testConstructor() {
LinkedHashMap<int, std::string> map;
CPPUNIT_ASSERT(map.isEmpty());
CPPUNIT_ASSERT(map.size() == 0);
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testConstructorI() {
LinkedHashMap<int, std::string> map(5);
CPPUNIT_ASSERT_EQUAL_MESSAGE("Created incorrect LinkedHashMap", 0, map.size());
try {
LinkedHashMap<int, std::string> map(-1);
CPPUNIT_FAIL("Should have thrown IllegalArgumentException for negative arg.");
} catch (IllegalArgumentException& e) {
}
LinkedHashMap<int, std::string> empty(0);
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown NoSuchElementException",
empty.get(1),
NoSuchElementException);
empty.put(1, "here");
CPPUNIT_ASSERT_MESSAGE("cannot get element", empty.get(1) == std::string("here"));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testConstructorIF() {
LinkedHashMap<int, std::string> map(5, 0.5f);
CPPUNIT_ASSERT_EQUAL_MESSAGE("Created incorrect LinkedHashMap", 0, map.size());
try {
LinkedHashMap<int, std::string> map(0, 0);
CPPUNIT_FAIL("Should have thrown IllegalArgumentException for negative arg.");
} catch (IllegalArgumentException& e) {
}
LinkedHashMap<int, std::string> empty(0, 0.25f);
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown NoSuchElementException",
empty.get(1),
NoSuchElementException);
empty.put(1, "here");
CPPUNIT_ASSERT_MESSAGE("cannot get element", empty.get(1) == std::string("here"));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testConstructorMap() {
LinkedHashMap<int, int> myMap;
for (int counter = 0; counter < 125; counter++) {
myMap.put(counter, counter);
}
LinkedHashMap<int, int> hashMap(myMap);
for (int counter = 0; counter < 125; counter++) {
CPPUNIT_ASSERT_MESSAGE("Failed to construct correct LinkedHashMap",
myMap.get(counter) == hashMap.get(counter));
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testClear() {
LinkedHashMap<int, std::string> hashMap;
hashMap.put(1, "one");
hashMap.put(3, "three");
hashMap.put(2, "two");
hashMap.clear();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Clear failed to reset size", 0, hashMap.size());
for (int i = 0; i < 125; i++) {
CPPUNIT_ASSERT_THROW_MESSAGE(
"Failed to clear all elements",
hashMap.get(i),
NoSuchElementException);
}
// Check clear on a large loaded map of Integer keys
LinkedHashMap<int, std::string> map;
for (int i = -32767; i < 32768; i++) {
map.put(i, "foobar");
}
map.clear();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to reset size on large integer map", 0, map.size());
for (int i = -32767; i < 32768; i++) {
CPPUNIT_ASSERT_THROW_MESSAGE(
"Failed to clear all elements",
map.get(i),
NoSuchElementException);
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testContainsKey() {
LinkedHashMap<int, std::string> hashMap;
hashMap.put(876, "test");
CPPUNIT_ASSERT_MESSAGE("Returned false for valid key", hashMap.containsKey(876));
CPPUNIT_ASSERT_MESSAGE("Returned true for invalid key", !hashMap.containsKey(1));
LinkedHashMap<int, std::string> hashMap2;
hashMap2.put(0, "test");
CPPUNIT_ASSERT_MESSAGE("Failed with key", hashMap2.containsKey(0));
CPPUNIT_ASSERT_MESSAGE("Failed with missing key matching hash", !hashMap2.containsKey(1));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testContainsValue() {
LinkedHashMap<int, std::string> hashMap;
hashMap.put(876, "test");
CPPUNIT_ASSERT_MESSAGE("Returned false for valid value", hashMap.containsValue("test"));
CPPUNIT_ASSERT_MESSAGE("Returned true for invalid valie", !hashMap.containsValue(""));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testEntrySet() {
LinkedHashMap<int, std::string> hashMap;
for (int i = 0; i < 50; i++) {
hashMap.put(i, Integer::toString(i));
}
Set<MapEntry<int, std::string> >& set = hashMap.entrySet();
Pointer< Iterator<MapEntry<int, std::string> > > iterator(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size", hashMap.size() == set.size());
while (iterator->hasNext()) {
MapEntry<int, std::string> entry = iterator->next();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect entry set",
hashMap.containsKey(entry.getKey()) && hashMap.containsValue(entry.getValue()));
}
iterator.reset(set.iterator());
set.remove(iterator->next());
CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove on set didn't take", 49, set.size());
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testGet() {
LinkedHashMap<int, std::string> hashMap;
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown NoSuchElementException",
hashMap.get(1),
NoSuchElementException);
hashMap.put(22, "HELLO");
CPPUNIT_ASSERT_EQUAL_MESSAGE("Get returned incorrect value for existing key",
std::string("HELLO"), hashMap.get(22));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testIsEmpty() {
LinkedHashMap<int, std::string> hashMap;
CPPUNIT_ASSERT_MESSAGE("Returned false for new map", hashMap.isEmpty());
hashMap.put(1, "1");
CPPUNIT_ASSERT_MESSAGE("Returned true for non-empty", !hashMap.isEmpty());
hashMap.clear();
CPPUNIT_ASSERT_MESSAGE("Returned false for cleared map", hashMap.isEmpty());
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testKeySet() {
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
Set<int>& set = hashMap.keySet();
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size()", set.size() == hashMap.size());
for (int i = 0; i < MAP_SIZE; i++) {
CPPUNIT_ASSERT_MESSAGE("Returned set does not contain all keys", set.contains(i));
}
{
LinkedHashMap<int, std::string> localMap;
localMap.put(0, "test");
Set<int>& intSet = localMap.keySet();
CPPUNIT_ASSERT_MESSAGE("Failed with zero key", intSet.contains(0));
}
{
LinkedHashMap<int, std::string> localMap;
localMap.put(1, "1");
localMap.put(102, "102");
localMap.put(203, "203");
Set<int>& intSet = localMap.keySet();
Pointer< Iterator<int> > it(intSet.iterator());
int remove1 = it->next();
it->hasNext();
it->remove();
int remove2 = it->next();
it->remove();
ArrayList<int> list;
list.add(1);
list.add(102);
list.add(203);
list.remove(remove1);
list.remove(remove2);
CPPUNIT_ASSERT_MESSAGE("Wrong result", it->next() == list.get(0));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong size", 1, localMap.size());
it.reset(intSet.iterator());
CPPUNIT_ASSERT_MESSAGE("Wrong contents", it->next() == list.get(0));
}
{
LinkedHashMap<int, std::string> map2(101);
map2.put(1, "1");
map2.put(4, "4");
Set<int>& intSet = map2.keySet();
Pointer< Iterator<int> > it2(intSet.iterator());
int remove3 = it2->next();
int next;
if (remove3 == 1) {
next = 4;
} else {
next = 1;
}
it2->hasNext();
it2->remove();
CPPUNIT_ASSERT_MESSAGE("Wrong result 2", it2->next() == next);
CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong size 2", 1, map2.size());
it2.reset(intSet.iterator());
CPPUNIT_ASSERT_MESSAGE("Wrong contents 2", it2->next() == next);
}
}
////////////////////////////////////////////////////////////////////////////////
namespace {
class MyKey {
private:
static int COUNTER;
int id;
public:
MyKey() : id(++COUNTER) {
}
int hashCode() const {
return 0;
}
bool operator==(const MyKey& key) const {
return this->id == key.id;
}
friend std::ostream& operator<<(std::ostream& stream, const MyKey& key);
};
std::ostream& operator<<(std::ostream& stream, const MyKey& key) {
stream << "MyKey: " << key.id;
return stream;
}
int MyKey::COUNTER = 0;
}
////////////////////////////////////////////////////////////////////////////////
namespace decaf {
namespace util {
template<>
struct HashCode<MyKey> {
typedef MyKey argument_type;
typedef int result_type;
int operator()(const MyKey& arg) const {
return arg.hashCode();
}
};
}}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testPut() {
{
LinkedHashMap<std::string, std::string> hashMap(101);
hashMap.put("KEY", "VALUE");
CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to install key/value pair",
std::string("VALUE"), hashMap.get("KEY"));
}
{
// Check my actual key instance is returned
LinkedHashMap<int, std::string> map;
for (int i = -32767; i < 32768; i++) {
map.put(i, "foobar");
}
int myKey = 0;
// Put a new value at the old key position
map.put(myKey, "myValue");
CPPUNIT_ASSERT(map.containsKey(myKey));
CPPUNIT_ASSERT_EQUAL(std::string("myValue"), map.get(myKey));
bool found = false;
Set<int>& intSet = map.keySet();
Pointer< Iterator<int> > itr(intSet.iterator());
while (itr->hasNext()) {
int key = itr->next();
found = (key == myKey);
if (found) {
break;
}
}
CPPUNIT_ASSERT_MESSAGE("Should find new key instance in hashashMap", found);
// Add a new key instance and check it is returned
CPPUNIT_ASSERT_NO_THROW(map.remove(myKey));
map.put(myKey, "myValue");
CPPUNIT_ASSERT(map.containsKey(myKey));
CPPUNIT_ASSERT_EQUAL(std::string("myValue"), map.get(myKey));
itr.reset(intSet.iterator());
while (itr->hasNext()) {
int key = itr->next();
found = (key == myKey);
if (found) {
break;
}
}
CPPUNIT_ASSERT_MESSAGE("Did not find new key instance in hashashMap", found);
}
{
// Ensure keys with identical hashcode are stored separately
LinkedHashMap<MyKey, std::string> map;
// Put non-equal object with same hashcode
MyKey aKey;
CPPUNIT_ASSERT(!map.containsKey(aKey));
map.put(aKey, "value");
MyKey aKey2;
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown NoSuchElementException",
map.remove(aKey2),
NoSuchElementException);
MyKey aKey3;
map.put(aKey3, "foobar");
CPPUNIT_ASSERT_EQUAL(std::string("foobar"), map.get(aKey3));
CPPUNIT_ASSERT_EQUAL(std::string("value"), map.get(aKey));
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testPutAll() {
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
LinkedHashMap<int, std::string> hashMap2;
hashMap2.putAll(hashMap);
for (int i = 0; i < 1000; i++) {
CPPUNIT_ASSERT_MESSAGE("Failed to put all elements into new Map",
hashMap2.get(i) == Integer::toString(i));
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testRemove() {
{
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
int size = hashMap.size();
CPPUNIT_ASSERT_NO_THROW_MESSAGE("Remove returned incorrect value", hashMap.remove(9));
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown a NoSuchElementException on get of non-existent key.",
hashMap.get(9),
NoSuchElementException);
CPPUNIT_ASSERT_MESSAGE("Failed to decrement size", hashMap.size() == (size - 1));
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown a NoSuchElementException on remove of non-existent key.",
hashMap.remove(9),
NoSuchElementException);
}
{
LinkedHashMap<int, std::string> hashMap;
for (int i = 0; i < 8192; i++) {
hashMap.put(i, "const");
}
for (int i = 0; i < 8192; i++) {
hashMap.put(i, Integer::toString(i));
}
for (int i = 8191; i >= 0; i--) {
std::string iValue = Integer::toString(i);
CPPUNIT_ASSERT_MESSAGE(std::string("Failed to replace value: ") + iValue,
hashMap.containsValue(iValue));
hashMap.remove(i);
CPPUNIT_ASSERT_MESSAGE(std::string("Failed to remove same value: ") + iValue,
!hashMap.containsValue(iValue));
}
}
{
// Ensure keys with identical hashcode are stored separately and removed correctly.
LinkedHashMap<MyKey, std::string> map;
// Put non-equal object with same hashcode
MyKey aKey;
CPPUNIT_ASSERT(!map.containsKey(aKey));
map.put(aKey, "value");
MyKey aKey2;
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should have thrown NoSuchElementException",
map.remove(aKey2),
NoSuchElementException);
MyKey aKey3;
map.put(aKey3, "foobar");
CPPUNIT_ASSERT_EQUAL(std::string("foobar"), map.get(aKey3));
CPPUNIT_ASSERT_EQUAL(std::string("value"), map.get(aKey));
map.remove(aKey);
map.remove(aKey3);
CPPUNIT_ASSERT(!map.containsKey(aKey));
CPPUNIT_ASSERT(map.isEmpty());
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testRehash() {
// This map should rehash on adding the ninth element.
LinkedHashMap<MyKey, int> hashMap(10, 0.5f);
// Ordered set of keys.
MyKey keyOrder[9];
// Store eight elements
for (int i = 0; i < 8; i++) {
hashMap.put(keyOrder[i], i);
}
// Check expected ordering
Set<MyKey>& keySet = hashMap.keySet();
std::vector<MyKey> returnedKeys = keySet.toArray();
for (int i = 0; i < 8; i++) {
CPPUNIT_ASSERT_EQUAL(keyOrder[i], returnedKeys[i]);
}
// The next put causes a rehash
hashMap.put(keyOrder[8], 8);
// Check expected insertion ordering
returnedKeys = keySet.toArray();
for (int i = 0; i < 9; i++) {
CPPUNIT_ASSERT_EQUAL(keyOrder[i], returnedKeys[i]);
}
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testSize() {
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
CPPUNIT_ASSERT_MESSAGE("Returned incorrect size", hashMap.size() == MAP_SIZE);
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testValues() {
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
Collection<std::string>& c = hashMap.values();
CPPUNIT_ASSERT_MESSAGE("Returned collection of incorrect size()", c.size() == hashMap.size());
for (int i = 0; i < MAP_SIZE; i++) {
CPPUNIT_ASSERT_MESSAGE("Returned collection does not contain all keys",
c.contains(Integer::toString(i)));
}
c.remove("10");
CPPUNIT_ASSERT_MESSAGE("Removing from collection should alter Map",
!hashMap.containsKey(10));
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testToString() {
LinkedHashMap<int, std::string> hashMap;
populateMap(hashMap);
std::string result = hashMap.toString();
CPPUNIT_ASSERT_MESSAGE("should return something", result != "");
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testEntrySetIterator() {
LinkedHashMap<int, std::string> map;
populateMap(map);
int count = 0;
Pointer< Iterator<MapEntry<int, std::string> > > iterator(map.entrySet().iterator());
while (iterator->hasNext()) {
MapEntry<int, std::string> entry = iterator->next();
CPPUNIT_ASSERT_EQUAL(count, entry.getKey());
CPPUNIT_ASSERT_EQUAL(Integer::toString(count), entry.getValue());
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't cover the expected range", count++ == MAP_SIZE);
iterator.reset(map.entrySet().iterator());
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
count = 0;
while (iterator->hasNext()) {
iterator->next();
iterator->remove();
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't remove the expected range", count++ == MAP_SIZE);
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testKeySetIterator() {
LinkedHashMap<int, std::string> map;
populateMap(map);
int count = 0;
Pointer< Iterator<int> > iterator(map.keySet().iterator());
while (iterator->hasNext()) {
int key = iterator->next();
CPPUNIT_ASSERT_EQUAL(count, key);
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't cover the expected range", count++ == MAP_SIZE);
iterator.reset(map.keySet().iterator());
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
count = 0;
while (iterator->hasNext()) {
iterator->next();
iterator->remove();
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't remove the expected range", count++ == MAP_SIZE);
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testValuesIterator() {
LinkedHashMap<int, std::string> map;
populateMap(map);
int count = 0;
Pointer< Iterator<std::string> > iterator(map.values().iterator());
while (iterator->hasNext()) {
std::string value = iterator->next();
CPPUNIT_ASSERT_EQUAL(Integer::toString(count), value);
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't cover the expected range", count++ == MAP_SIZE);
iterator.reset(map.values().iterator());
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
count = 0;
while (iterator->hasNext()) {
iterator->next();
iterator->remove();
count++;
}
CPPUNIT_ASSERT_MESSAGE("Iterator didn't remove the expected range", count++ == MAP_SIZE);
CPPUNIT_ASSERT_THROW_MESSAGE(
"Should throw an IllegalStateException",
iterator->remove(),
IllegalStateException);
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testOrderedEntrySet() {
int i;
int size = 100;
{
LinkedHashMap<int, std::string> map;
populateMap(map, size);
Set<MapEntry<int, std::string> >& set = map.entrySet();
Pointer< Iterator<MapEntry<int, std::string> > > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 1", map.size() == set.size());
for (i = 0; iter->hasNext(); i++) {
MapEntry<int, std::string> entry = iter->next();
int key = entry.getKey();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect entry set 1", key == i);
}
}
LinkedHashMap<int, std::string> map2(200, .75f, true);
populateMap(map2, size);
Set<MapEntry<int, std::string> >& set = map2.entrySet();
Pointer< Iterator<MapEntry<int, std::string> > > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 2", map2.size() == set.size());
for (i = 0; i < size && iter->hasNext(); i++) {
MapEntry<int, std::string> entry = iter->next();
int key = entry.getKey();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect entry set 2", key == i);
}
/* fetch the even numbered entries to affect traversal order */
int p = 0;
for (i = 0; i < size; i += 2) {
std::string ii = map2.get(i);
p = p + Integer::parseInt(ii);
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("invalid sum of even numbers", 2450, p);
set = map2.entrySet();
iter.reset(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 3", map2.size() == set.size());
for (i = 1; i < size && iter->hasNext(); i += 2) {
MapEntry<int, std::string> entry = iter->next();
int key = entry.getKey();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect entry set 3", key, i);
}
for (i = 0; i < size && iter->hasNext(); i += 2) {
MapEntry<int, std::string> entry = iter->next();
int key = entry.getKey();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect entry set 4", key, i);
}
CPPUNIT_ASSERT_MESSAGE("Entries left to iterate on", !iter->hasNext());
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testOrderedKeySet() {
int i;
int size = 100;
{
LinkedHashMap<int, std::string> map;
populateMap(map, size);
Set<int>& set = map.keySet();
Pointer< Iterator<int> > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 1", map.size() == set.size());
for (i = 0; iter->hasNext(); i++) {
int key = iter->next();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect key set 1", key == i);
}
}
LinkedHashMap<int, std::string> map2(200, .75f, true);
populateMap(map2, size);
Set<int>& set = map2.keySet();
Pointer< Iterator<int> > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 2", map2.size() == set.size());
for (i = 0; i < size && iter->hasNext(); i++) {
int key = iter->next();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect key set 2", key == i);
}
/* fetch the even numbered entries to affect traversal order */
int p = 0;
for (i = 0; i < size; i += 2) {
std::string ii = map2.get(i);
p = p + Integer::parseInt(ii);
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("invalid sum of even numbers", 2450, p);
set = map2.keySet();
iter.reset(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 3", map2.size() == set.size());
for (i = 1; i < size && iter->hasNext(); i += 2) {
int key = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect key set 3", key, i);
}
for (i = 0; i < size && iter->hasNext(); i += 2) {
int key = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect key set 4", key, i);
}
CPPUNIT_ASSERT_MESSAGE("Entries left to iterate on", !iter->hasNext());
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testOrderedValues() {
int i;
int size = 100;
{
LinkedHashMap<int, int> map;
for (i = 0; i < size; i++) {
map.put(i, i * 2);
}
Collection<int>& set = map.values();
Pointer< Iterator<int> > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 1", map.size() == set.size());
for (i = 0; iter->hasNext(); i++) {
int value = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect values set 1", value, i * 2);
}
}
LinkedHashMap<int, int> map2(200, .75f, true);
for (i = 0; i < size; i++) {
map2.put(i, i * 2);
}
Collection<int>& set = map2.values();
Pointer< Iterator<int> > iter(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 2", map2.size() == set.size());
for (i = 0; i < size && iter->hasNext(); i++) {
int value = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect values set 2", value, i * 2);
}
/* fetch the even numbered entries to affect traversal order */
int p = 0;
for (i = 0; i < size; i += 2) {
p = p + map2.get(i);
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("invalid sum of even numbers", 2450 * 2, p);
set = map2.values();
iter.reset(set.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 3", map2.size() == set.size());
for (i = 1; i < size && iter->hasNext(); i += 2) {
int value = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect values set 3", value, i * 2);
}
for (i = 0; i < size && iter->hasNext(); i += 2) {
int value = iter->next();
CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect values set 4", value, i * 2);
}
CPPUNIT_ASSERT_MESSAGE("Entries left to iterate on", !iter->hasNext());
}
////////////////////////////////////////////////////////////////////////////////
namespace {
class CacheMap : public LinkedHashMap<int, int> {
public:
int removals;
CacheMap() : LinkedHashMap<int, int>(), removals(0) {
}
virtual ~CacheMap() {}
protected:
virtual bool removeEldestEntry(const MapEntry<int, int>& eldest) {
return size() > 5;
}
virtual void onEviction(const MapEntry<int, int>& eldest) {
removals++;
}
};
}
////////////////////////////////////////////////////////////////////////////////
void LinkedHashMapTest::testRemoveEldest() {
int i;
int size = 10;
CacheMap map;
for (i = 0; i < size; i++) {
map.put(i, i * 2);
}
Collection<int>& values = map.values();
Pointer< Iterator<int> > iter(values.iterator());
CPPUNIT_ASSERT_MESSAGE("Returned set of incorrect size 1", map.size() == values.size());
for (i = 5; iter->hasNext(); i++) {
int current = iter->next();
CPPUNIT_ASSERT_MESSAGE("Returned incorrect entry set 1", current == i * 2);
}
CPPUNIT_ASSERT_MESSAGE("Entries left in map", !iter->hasNext());
CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect number of removals", 5, map.removals);
}