svn commit: r929392 - in /ofbiz/trunk/framework/base: build.xml src/org/ofbiz/base/util/cache/
Locked
 
|
Author: doogie
Date: Wed Mar 31 06:05:05 2010 New Revision: 929392 URL: http://svn.apache.org/viewvc?rev=929392&view=rev Log: Start UtilCache tests. Added: ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/ ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/UtilCacheTests.java Modified: ofbiz/trunk/framework/base/build.xml ofbiz/trunk/framework/base/testdef/basetests.xml Modified: ofbiz/trunk/framework/base/build.xml URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/base/build.xml?rev=929392&r1=929391&r2=929392&view=diff ============================================================================== --- ofbiz/trunk/framework/base/build.xml (original) +++ ofbiz/trunk/framework/base/build.xml Wed Mar 31 06:05:05 2010 @@ -48,6 +48,7 @@ under the License. <file name="org/ofbiz/base/util/string/test/FlexibleStringExpanderTests.java"/> <file name="org/ofbiz/base/util/collections/test/FlexibleMapAccessorTests.java"/> <file name="org/ofbiz/base/util/test/TimeDurationTests.java"/> + <file name="org/ofbiz/base/util/cache/test/UtilCacheTests.java"/> <file name="org/ofbiz/base/json/test/JSONTests.java"/> <file name="org/ofbiz/base/conversion/test/DateTimeTests.java"/> <file name="org/ofbiz/base/conversion/test/MiscTests.java"/> Added: ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/UtilCacheTests.java URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/UtilCacheTests.java?rev=929392&view=auto ============================================================================== --- ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/UtilCacheTests.java (added) +++ ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/test/UtilCacheTests.java Wed Mar 31 06:05:05 2010 @@ -0,0 +1,369 @@ +/******************************************************************************* + * 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. + *******************************************************************************/ +package org.ofbiz.base.util.cache.test; + +import java.io.Serializable; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; + +import org.ofbiz.base.util.Debug; +import org.ofbiz.base.util.UtilMisc; +import org.ofbiz.base.util.UtilObject; +import org.ofbiz.base.util.cache.CacheListener; +import org.ofbiz.base.util.cache.UtilCache; +import org.ofbiz.base.test.GenericTestCaseBase; + +public class UtilCacheTests extends GenericTestCaseBase implements Serializable { + public static final String module = UtilCacheTests.class.getName(); + + protected static abstract class Change<V> { + protected int count = 1; + } + + protected static final class Removal<V> extends Change<V> { + protected final V oldValue; + + protected Removal(V oldValue) { + this.oldValue = oldValue; + } + + public int hashCode() { + return UtilObject.doHashCode(oldValue); + } + + public boolean equals(Object o) { + if (o instanceof Removal) { + Removal other = (Removal) o; + return UtilObject.equalsHelper(oldValue, other.oldValue); + } + return false; + } + } + + protected static final class Addition<V> extends Change<V> { + protected final V newValue; + + protected Addition(V newValue) { + this.newValue = newValue; + } + + public int hashCode() { + return UtilObject.doHashCode(newValue); + } + + public boolean equals(Object o) { + if (o instanceof Addition) { + Addition other = (Addition) o; + return UtilObject.equalsHelper(newValue, other.newValue); + } + return false; + } + } + + protected static final class Update<V> extends Change<V> { + protected final V newValue; + protected final V oldValue; + + protected Update(V newValue, V oldValue) { + this.newValue = newValue; + this.oldValue = oldValue; + } + + public int hashCode() { + return UtilObject.doHashCode(newValue) ^ UtilObject.doHashCode(oldValue); + } + + public boolean equals(Object o) { + if (o instanceof Update) { + Update other = (Update) o; + if (!UtilObject.equalsHelper(newValue, other.newValue)) { + return false; + } + return UtilObject.equalsHelper(oldValue, other.oldValue); + } + return false; + } + } + + protected static class Listener<K, V> implements CacheListener<K, V> { + protected Map<K, Set<Change<V>>> changeMap = new HashMap<K, Set<Change<V>>>(); + + private void add(K key, Change<V> change) { + Set<Change<V>> changeSet = changeMap.get(key); + if (changeSet == null) { + changeSet = new HashSet<Change<V>>(); + changeMap.put(key, changeSet); + } + for (Change<V> checkChange: changeSet) { + if (checkChange.equals(change)) { + checkChange.count++; + return; + } + } + changeSet.add(change); + } + + public synchronized void noteKeyRemoval(UtilCache<K, V> cache, K key, V oldValue) { + add(key, new Removal<V>(oldValue)); + } + + public synchronized void noteKeyAddition(UtilCache<K, V> cache, K key, V newValue) { + add(key, new Addition<V>(newValue)); + } + + public synchronized void noteKeyUpdate(UtilCache<K, V> cache, K key, V newValue, V oldValue) { + add(key, new Update<V>(newValue, oldValue)); + } + + public boolean equals(Object o) { + Listener other = (Listener) o; + return changeMap.equals(other.changeMap); + } + } + + private static <K, V> Listener<K, V> createListener(UtilCache<K, V> cache) { + Listener<K, V> listener = new Listener<K, V>(); + cache.addListener(listener); + return listener; + } + + public UtilCacheTests(String name) { + super(name); + } + + private <K, V> UtilCache<K, V> createUtilCache(int maxSize, int maxInMemory, long ttl, boolean useSoftReference, boolean useFileSystemStore) { + return UtilCache.createUtilCache(getClass().getName() + "." + getName(), maxSize, maxInMemory, ttl, useSoftReference, useFileSystemStore); + } + + private static <K, V> void assertUtilCacheSettings(UtilCache<K, V> cache, Integer maxSize, Integer maxInMemory, Long expireTime, Boolean useSoftReference, Boolean useFileSystemStore) { + if (maxSize != null) { + assertEquals(cache.getName() + ":maxSize", maxSize.intValue(), cache.getMaxSize()); + } + if (maxInMemory != null) { + assertEquals(cache.getName() + ":maxInMemory", maxInMemory.intValue(), cache.getMaxInMemory()); + } + if (expireTime != null) { + assertEquals(cache.getName() + ":expireTime", expireTime.longValue(), cache.getExpireTime()); + } + if (useSoftReference != null) { + assertEquals(cache.getName() + ":useSoftReference", useSoftReference.booleanValue(), cache.getUseSoftReference()); + } + if (useFileSystemStore != null) { + assertEquals(cache.getName() + ":useFileSystemStore", useFileSystemStore.booleanValue(), cache.getUseFileSystemStore()); + } + assertEquals("initial empty", true, cache.isEmpty()); + assertEquals("empty keys", Collections.emptySet(), cache.getCacheLineKeys()); + assertEquals("empty values", Collections.emptyList(), cache.values()); + assertSame("find cache", cache, UtilCache.findCache(cache.getName())); + assertNotSame("new cache", cache, UtilCache.createUtilCache()); + } + + public void testCreateUtilCache() { + String name = getClass().getName() + "." + getName(); + assertUtilCacheSettings(UtilCache.createUtilCache(), null, null, null, null, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name), null, null, null, null, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, false), null, null, null, Boolean.FALSE, null); + //assertUtilCacheSettings(UtilCache.createUtilCache(name, true), null, null, null, Boolean.TRUE, null); + assertUtilCacheSettings(UtilCache.createUtilCache(5, 15000), 5, null, 15000L, null, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, 6, 16000), 6, null, 16000L, null, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, 7, 17000, false), 7, null, 17000L, Boolean.FALSE, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, 8, 18000, true), 8, null, 18000L, Boolean.TRUE, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, 9, 5, 19000, false, false), 9, 5, 19000L, Boolean.FALSE, null); + //assertUtilCacheSettings(UtilCache.createUtilCache(name, 10, 6, 20000, false, true), 10, 6, 20000L, Boolean.FALSE, null); + assertUtilCacheSettings(UtilCache.createUtilCache(name, 11, 7, 21000, false, false, "a", "b"), 11, 7, 21000L, Boolean.FALSE, Boolean.FALSE); + //assertUtilCacheSettings(UtilCache.createUtilCache(name, 12, 8, 22000, false, true, "c", "d"), 12, 8, 22000L, Boolean.FALSE, Boolean.TRUE); + } + + public <K, V> void assertKey(String label, UtilCache<K, V> cache, K key, V value, V other, int size, Map<K, V> map) { + assertNull(label + ":get-empty", cache.get(key)); + assertFalse(label + ":containsKey-empty", cache.containsKey(key)); + V oldValue = cache.put(key, other); + assertTrue(label + ":containsKey-class", cache.containsKey(key)); + assertEquals(label + ":get-class", other, cache.get(key)); + assertNull(label + ":oldValue-class", oldValue); + assertEquals(label + ":size-class", size, cache.size()); + oldValue = cache.put(key, value); + assertTrue(label + ":containsKey-value", cache.containsKey(key)); + assertEquals(label + ":get-value", value, cache.get(key)); + assertEquals(label + ":oldValue-value", other, oldValue); + assertEquals(label + ":size-value", size, cache.size()); + map.put(key, value); + assertEquals(label + ":map-keys", map.keySet(), cache.getCacheLineKeys()); + assertEquals(label + ":map-values", map.values(), cache.values()); + } + + private <K, V> void assertHasSingleKey(UtilCache<K, V> cache, K key, V value) { + assertFalse("is-empty", cache.isEmpty()); + assertEquals("size", 1, cache.size()); + assertTrue("found", cache.containsKey(key)); + assertTrue("validKey", UtilCache.validKey(cache.getName(), key)); + assertFalse("validKey", UtilCache.validKey(":::" + cache.getName(), key)); + assertEquals("get", value, cache.get(key)); + assertEquals("keys", new HashSet<K>(UtilMisc.toList(key)), cache.getCacheLineKeys()); + assertEquals("values", UtilMisc.toList(value), cache.values()); + } + + private <K, V> void assertNoSingleKey(UtilCache<K, V> cache, K key) { + assertFalse("not-found", cache.containsKey(key)); + assertFalse("validKey", UtilCache.validKey(cache.getName(), key)); + assertNull("no-get", cache.get(key)); + assertNull("remove", cache.remove(key)); + assertTrue("is-empty", cache.isEmpty()); + assertEquals("size", 0, cache.size()); + assertEquals("keys", Collections.emptySet(), cache.getCacheLineKeys()); + assertEquals("values", Collections.emptyList(), cache.values()); + } + + public void testSimple() throws Exception { + UtilCache<String, String> cache = createUtilCache(5, 0, 0, false, false); + Listener<String, String> gotListener = createListener(cache); + Listener<String, String> wantedListener = new Listener<String, String>(); + for (int i = 0; i < 2; i++) { + assertTrue("UtilCacheTable.keySet", UtilCache.getUtilCacheTableKeySet().contains(cache.getName())); + assertSame("UtilCache.findCache", cache, UtilCache.findCache(cache.getName())); + assertSame("UtilCache.getOrCreateUtilCache", cache, UtilCache.getOrCreateUtilCache(cache.getName(), cache.getMaxSize(), cache.getMaxInMemory(), cache.getExpireTime(), cache.getUseSoftReference(), cache.getUseFileSystemStore())); + + assertNoSingleKey(cache, "one"); + long origByteSize = cache.getSizeInBytes(); + + wantedListener.noteKeyAddition(cache, null, "null"); + assertNull("put", cache.put(null, "null")); + assertHasSingleKey(cache, null, "null"); + long nullByteSize = cache.getSizeInBytes(); + assertThat(nullByteSize, greaterThan(origByteSize)); + + wantedListener.noteKeyRemoval(cache, null, "null"); + assertEquals("remove", "null", cache.remove(null)); + assertNoSingleKey(cache, null); + + wantedListener.noteKeyAddition(cache, "one", "uno"); + assertNull("put", cache.put("one", "uno")); + assertHasSingleKey(cache, "one", "uno"); + long unoByteSize = cache.getSizeInBytes(); + assertThat(unoByteSize, greaterThan(origByteSize)); + + wantedListener.noteKeyUpdate(cache, "one", "single", "uno"); + assertEquals("replace", "uno", cache.put("one", "single")); + assertHasSingleKey(cache, "one", "single"); + long singleByteSize = cache.getSizeInBytes(); + assertThat(singleByteSize, greaterThan(origByteSize)); + assertThat(singleByteSize, greaterThan(unoByteSize)); + + wantedListener.noteKeyRemoval(cache, "one", "single"); + assertEquals("remove", "single", cache.remove("one")); + assertNoSingleKey(cache, "one"); + assertEquals("byteSize", origByteSize, cache.getSizeInBytes()); + + wantedListener.noteKeyAddition(cache, "one", "uno"); + assertNull("put", cache.put("one", "uno")); + assertHasSingleKey(cache, "one", "uno"); + + wantedListener.noteKeyUpdate(cache, "one", "only", "uno"); + assertEquals("replace", "uno", cache.put("one", "only")); + assertHasSingleKey(cache, "one", "only"); + + wantedListener.noteKeyRemoval(cache, "one", "only"); + assertEquals("remove", "only", cache.remove("one")); + assertNoSingleKey(cache, "one"); + assertEquals("byteSize", origByteSize, cache.getSizeInBytes()); + + cache.setExpireTime(100); + wantedListener.noteKeyAddition(cache, "one", "uno"); + assertNull("put", cache.put("one", "uno")); + assertHasSingleKey(cache, "one", "uno"); + + wantedListener.noteKeyRemoval(cache, "one", "uno"); + Thread.sleep(200); + assertNoSingleKey(cache, "one"); + } + + assertEquals("get-miss", 10, cache.getMissCountNotFound()); + assertEquals("get-miss-total", 10, cache.getMissCountTotal()); + assertEquals("get-hit", 24, cache.getHitCount()); + assertEquals("remove-hit", 6, cache.getRemoveHitCount()); + assertEquals("remove-miss", 10, cache.getRemoveMissCount()); + cache.removeListener(gotListener); + assertEquals("listener", wantedListener, gotListener); + cache.clear(); + } + + public void testChangeSize() throws Exception { + int size = 5; + long ttl = 2000; + UtilCache<String, Serializable> cache = createUtilCache(size, size, ttl, false, false); + Map<String, Serializable> map = new HashMap<String, Serializable>(); + for (int i = 0; i < size; i++) { + String s = Integer.toString(i); + assertKey(s, cache, s, new String(s), new String(":" + s), i + 1, map); + } + cache.setMaxSize(2); + for (int i = 0; i < size - 2; i++) { + String s = Integer.toString(i); + map.remove(s); + } + assertEquals("size", 2, cache.size()); + } + + private void expireTest(UtilCache<String, Serializable> cache, int size, long ttl) throws Exception { + Map<String, Serializable> map = new HashMap<String, Serializable>(); + for (int i = 0; i < size; i++) { + String s = Integer.toString(i); + assertKey(s, cache, s, new String(s), new String(":" + s), i + 1, map); + } + Thread.sleep(ttl + 500); + map.clear(); + for (int i = 0; i < size; i++) { + String s = Integer.toString(i); + assertNull("no-key(" + s + ")", cache.get(s)); + } + assertEquals("map-keys", map.keySet(), cache.getCacheLineKeys()); + assertEquals("map-values", map.values(), cache.values()); + for (int i = 0; i < size; i++) { + String s = Integer.toString(i); + assertKey(s, cache, s, new String(s), new String(":" + s), i + 1, map); + } + assertEquals("map-keys", map.keySet(), cache.getCacheLineKeys()); + assertEquals("map-values", map.values(), cache.values()); + } + + public void testExpire() throws Exception { + UtilCache<String, Serializable> cache = createUtilCache(5, 5, 2000, false, false); + expireTest(cache, 5, 2000); + long start = System.currentTimeMillis(); + useAllMemory(); + long end = System.currentTimeMillis(); + long ttl = end - start + 1000; + cache = createUtilCache(1, 1, ttl, true, false); + expireTest(cache, 1, ttl); + assertFalse("not empty", cache.isEmpty()); + useAllMemory(); + assertNull("not-key(0)", cache.get("0")); + assertTrue("empty", cache.isEmpty()); + } +} Modified: ofbiz/trunk/framework/base/testdef/basetests.xml URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/base/testdef/basetests.xml?rev=929392&r1=929391&r2=929392&view=diff ============================================================================== --- ofbiz/trunk/framework/base/testdef/basetests.xml (original) +++ ofbiz/trunk/framework/base/testdef/basetests.xml Wed Mar 31 06:05:05 2010 @@ -28,6 +28,7 @@ <junit-test-suite class-name="org.ofbiz.base.util.string.test.FlexibleStringExpanderTests"/> <junit-test-suite class-name="org.ofbiz.base.util.collections.test.FlexibleMapAccessorTests"/> <junit-test-suite class-name="org.ofbiz.base.util.test.TimeDurationTests"/> + <junit-test-suite class-name="org.ofbiz.base.util.cache.test.UtilCacheTests"/> <junit-test-suite class-name="org.ofbiz.base.conversion.test.DateTimeTests.java"/> <junit-test-suite class-name="org.ofbiz.base.conversion.test.MiscTests.java"/> <junit-test-suite class-name="org.ofbiz.base.util.test.UtilIOTests"/> |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |