/*
* 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.apache.openjpa.persistence.kernel;
import java.util.Comparator;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.openjpa.persistence.kernel.common.apps.ProxiesPC;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.openjpa.persistence.OpenJPAEntityManager;
import org.apache.openjpa.util.Proxy;
public class TestProxies2 extends BaseKernelTest {
private int _oid = 0;
private Date _date = null;
private java.sql.Date _sqlDate = null;
private java.sql.Timestamp _timestamp = null;
public TestProxies2(String casename) {
super(casename);
}
public void setUp() throws Exception {
super.setUp(ProxiesPC.class);
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
long now = System.currentTimeMillis();
_date = new Date(now);
_sqlDate = new java.sql.Date(now);
_timestamp = new java.sql.Timestamp(now);
ProxiesPC pc = new ProxiesPC("main");
pc.setDate(_date);
pc.setSQLDate(_sqlDate);
pc.setTimestamp(_timestamp);
pc.getStringSet().add("val1");
pc.getStringSet().add("val2");
pc.getStringSet().add("val3");
pc.getStringSet().add(null);
pc.getProxySet().add(new ProxiesPC("set1"));
pc.getProxySet().add(new ProxiesPC("set2"));
pc.getProxySet().add(new ProxiesPC("set3"));
pc.getStringMap().put("key1", "1");
pc.getStringMap().put("key2", "2");
pc.getStringMap().put("key3", "3");
pc.getStringMap().put(null, "null");
pc.getStringMap().put("null", null);
pc.getProxyMap().put("key1", new ProxiesPC("map1"));
pc.getProxyMap().put("key2", new ProxiesPC("map2"));
pc.getProxyMap().put("key3", new ProxiesPC("map3"));
pc.getList().add("val1");
pc.getList().add("val1");
pc.getList().add("val2");
pc.getList().add("val3");
pc.getList().add("val3");
pm.persist(pc);
_oid = pc.getId();
endTx(pm);
endEm(pm);
}
public void testStringSet() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
Set set = pc.getStringSet();
assertEquals(4, set.size());
assertTrue(set.contains("val1"));
assertTrue(set.contains("val2"));
assertTrue(set.contains("val3"));
assertTrue(set.contains(null));
// do some mods to try to confuse the proxy
set.remove("val1");
set.remove("val1");
set.add("val4");
set.remove("val4");
set.add("val5");
set.add("val5");
endTx(pm);
endEm(pm);
// re-retrieve and check set
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
set = pc.getStringSet();
assertEquals(4, set.size());
assertTrue(!set.contains("val1"));
assertTrue(set.contains("val2"));
assertTrue(set.contains("val3"));
assertTrue(!set.contains("val4"));
assertTrue(set.contains("val5"));
assertTrue(set.contains(null));
endEm(pm);
}
public void testStringMap() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
Map map = pc.getStringMap();
assertEquals(5, map.size());
assertEquals("1", map.get("key1"));
assertEquals("2", map.get("key2"));
assertEquals("3", map.get("key3"));
assertNull(map.get("null"));
assertEquals("null", map.get(null));
// do some mods to try to confuse the proxy
map.put("key1", "1a");
map.put("key1", "1b");
map.put("key4", "4");
map.remove("key4");
map.remove("foo");
map.put("key5", "5");
endTx(pm);
endEm(pm);
// re-retrieve and check map
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
map = pc.getStringMap();
assertEquals(6, map.size());
assertEquals("1b", map.get("key1"));
assertEquals("5", map.get("key5"));
endEm(pm);
}
public void testProxySet() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
Set set = pc.getProxySet();
assertEquals(3, set.size());
Iterator itr = set.iterator();
ProxiesPC set1 = (ProxiesPC) itr.next();
ProxiesPC set2 = (ProxiesPC) itr.next();
ProxiesPC set3 = (ProxiesPC) itr.next();
assertEquals("set1", set1.getName());
assertEquals("set2", set2.getName());
assertEquals("set3", set3.getName());
// do some mods to try to confuse the proxy
set.remove(set1);
set.remove(set1);
ProxiesPC set4 = new ProxiesPC("set4");
set.add(set4);
set.remove(set4);
ProxiesPC set5 = new ProxiesPC("set5");
set.add(set5);
set.add(set5);
endTx(pm);
endEm(pm);
// re-retrieve and check set
pm = getPM(true, false);
startTx(pm);
pc = pm.find(ProxiesPC.class, _oid);
pm.refresh(pc);
set = pc.getProxySet();
assertEquals(3, set.size());
itr = set.iterator();
set1 = (ProxiesPC) itr.next();
set2 = (ProxiesPC) itr.next();
set3 = (ProxiesPC) itr.next();
assertEquals("set2", set1.getName());
assertEquals("set3", set2.getName());
assertEquals("set5", set3.getName());
endTx(pm);
endEm(pm);
}
public void testProxyMap() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
Map map = pc.getProxyMap();
assertEquals("original map size is correct: 3", 3, map.size());
ProxiesPC map1 = (ProxiesPC) map.get("key1");
ProxiesPC map2 = (ProxiesPC) map.get("key2");
ProxiesPC map3 = (ProxiesPC) map.get("key3");
assertEquals("map1", map1.getName());
assertEquals("map2", map2.getName());
assertEquals("map3", map3.getName());
// do some mods to try to confuse the proxy
ProxiesPC map1a = new ProxiesPC("map1a");
map.put("key1", map1a);
ProxiesPC map1b = new ProxiesPC("map1b");
map.put("key1", map1b);
map.put("key4", new ProxiesPC("map4"));
map.remove("key4");
map.remove("foo");
map.put("key5", new ProxiesPC("map5"));
endTx(pm);
endEm(pm);
// re-retrieve and check map
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
startTx(pm);
pm.refresh(pc);
map = pc.getProxyMap();
assertEquals(4, map.size());
assertEquals("map1b", ((ProxiesPC) map.get("key1")).getName());
assertEquals("map5", ((ProxiesPC) map.get("key5")).getName());
endTx(pm);
endEm(pm);
}
public void testReplace() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// totally replace set
Set set = new HashSet();
set.add("new");
pc.setStringSet(set);
endTx(pm);
endEm(pm);
// re-retrieve and check set
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
set = pc.getStringSet();
assertEquals(1, set.size());
assertTrue(set.contains("new"));
endEm(pm);
}
public void testComparators() {
// make sure the system uses the initial field value to find
// comparators
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
assertNotNull("pc is null", pc);
assertTrue("pc.getComp() is not instanceof Proxy",
pc.getComp() instanceof Proxy);
assertTrue(
"(TreeSet) is not pc.getComp()).comparator() instanceof ComparableComparator",
((TreeSet) pc.getComp())
.comparator() instanceof ComparableComparator);
pm.evict(pc);
endTx(pm);
// see if it still saves comparator after transition to hollow
// and back
assertTrue("pc.getComp() is not instanceof ProxyTreeSet",
pc.getComp() instanceof Proxy);
Comparator compart = ((TreeSet) pc.getComp()).comparator();
assertNotNull("compart is null", compart);
assertTrue(
"((TreeSet) is not pc.getComp()).comparator()instanceof ComparableComparator",
((TreeSet) pc.getComp())
.comparator() instanceof ComparableComparator);
endEm(pm);
}
// FIX ME: Moving fix to essex
/*public void testList() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
List list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val2", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val3", list.get(4));
// do some mods to try to confuse the proxy
list.remove("val2");
list.add("val4");
list.remove("val4");
list.add("val5");
list.add("val6");
list.add("val6");
endTx(pm);
endEm(pm);
// re-retrieve and modify again to check holes in ordering
pm = getPM(false, false);
startTx(pm);
pc = (ProxiesPC) pm.find(ProxiesPC.class, _oid);
list = pc.getList();
assertEquals(7, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val3", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val5", list.get(4));
assertEquals("val6", list.get(5));
assertEquals("val6", list.get(6));
list.remove("val5");
list.add("val7");
endTx(pm);
endEm(pm);
// re-retrieve and check final contents
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
list = pc.getList();
assertEquals(7, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val3", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val6", list.get(4));
assertEquals("val6", list.get(5));
assertEquals("val7", list.get(6));
endEm(pm);
}
public void testListDisablesChangeTracking() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
List list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val2", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val3", list.get(4));
// removing a copy of val3 should disable tracking
list.remove("val2");
list.remove("val3");
list.add("val5");
list.add("val5");
endTx(pm);
endEm(pm);
// re-retrieve and change again to check ordering
pm = getPM(false, false);
startTx(pm);
pc = pm.find(ProxiesPC.class, _oid);
list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val3", list.get(2));
assertEquals("val5", list.get(3));
assertEquals("val5", list.get(4));
list.remove("val3");
list.add("val6");
endTx(pm);
endEm(pm);
// check final contents
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val6", list.get(2));
assertEquals("val5", list.get(3));
assertEquals("val5", list.get(4));
endEm(pm);
}
*/
public void testChangeListOrder() {
OpenJPAEntityManager pm = getPM(false, false);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
// check that orig values are correct
List list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val2", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val3", list.get(4));
// reorder val2
list.remove("val2");
list.add("val2");
endTx(pm);
endEm(pm);
// re-retrieve to check ordering
pm = getPM(false, false);
pc = pm.find(ProxiesPC.class, _oid);
list = pc.getList();
assertEquals(5, list.size());
assertEquals("val1", list.get(0));
assertEquals("val1", list.get(1));
assertEquals("val2", list.get(2));
assertEquals("val3", list.get(3));
assertEquals("val3", list.get(4));
endEm(pm);
}
public void testDate() {
OpenJPAEntityManager pm = getPM(true, true);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
Date date = pc.getDate();
assertNotNull(date);
// dates can lose precision, but make sure same day
assertEquals(_date.getYear(), date.getYear());
assertEquals(_date.getMonth(), date.getMonth());
assertEquals(_date.getDate(), date.getDate());
// make sure proxied
assertTrue(!pm.isDirty(pc));
date.setTime(System.currentTimeMillis() + 1000 * 60 * 60 * 24);
assertTrue(pm.isDirty(pc));
endTx(pm);
assertEquals(date, pc.getDate());
endEm(pm);
}
public void testSQLDate() {
OpenJPAEntityManager pm = getPM(true, true);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
java.sql.Date date = pc.getSQLDate();
assertNotNull(date);
// dates can lose precision, but make sure same day
assertEquals(_sqlDate.getYear(), date.getYear());
assertEquals(_sqlDate.getMonth(), date.getMonth());
assertEquals(_sqlDate.getDate(), date.getDate());
// make sure proxied
assertTrue(!pm.isDirty(pc));
date.setTime(System.currentTimeMillis() + 1000 * 60 * 60 * 24);
assertTrue(pm.isDirty(pc));
endTx(pm);
assertEquals(date, pc.getSQLDate());
endEm(pm);
}
public void testTimestamp() {
OpenJPAEntityManager pm = getPM(true, true);
startTx(pm);
ProxiesPC pc = pm.find(ProxiesPC.class, _oid);
java.sql.Timestamp tstamp = pc.getTimestamp();
assertNotNull(tstamp);
// dates can lose precision, but make sure same day
assertEquals(_timestamp.getYear(), tstamp.getYear());
assertEquals(_timestamp.getMonth(), tstamp.getMonth());
assertEquals(_timestamp.getDate(), tstamp.getDate());
// make sure proxied
assertTrue(!pm.isDirty(pc));
tstamp.setNanos(100);
assertTrue(pm.isDirty(pc));
endTx(pm);
assertEquals(tstamp, pc.getTimestamp());
endEm(pm);
}
}