db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r158176 [71/79] - in incubator/jdo/trunk/ri11: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/ejb/ src/java/org/apache/jdo/enhancer/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/enhancer/ src/java/org/apache/jdo/impl/enhancer/classfile/ src/java/org/apache/jdo/impl/enhancer/core/ src/java/org/apache/jdo/impl/enhancer/generator/ src/java/org/apache/jdo/impl/enhancer/meta/ src/java/org/apache/jdo/impl/enhancer/meta/model/ src/java/org/apache/jdo/impl/enhancer/meta/prop/ src/java/org/apache/jdo/impl/enhancer/meta/util/ src/java/org/apache/jdo/impl/enhancer/util/ src/java/org/apache/jdo/impl/fostore/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/impl/model/ src/java/org/apache/jdo/impl/model/java/ src/java/org/apache/jdo/impl/model/java/runtime/ src/java/org/apache/jdo/impl/model/jdo/ src/java/org/apache/jdo/impl/model/jdo/caching/ src/java/org/apache/jdo/impl/model/jdo/util/ src/java/org/apache/jdo/impl/model/jdo/xml/ src/java/org/apache/jdo/impl/pm/ src/java/org/apache/jdo/impl/sco/ src/java/org/apache/jdo/impl/state/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/ src/java/org/apache/jdo/model/ src/java/org/apache/jdo/model/java/ src/java/org/apache/jdo/model/jdo/ src/java/org/apache/jdo/pm/ src/java/org/apache/jdo/sco/ src/java/org/apache/jdo/state/ src/java/org/apache/jdo/store/ src/java/org/apache/jdo/util/ test/ test/conf/ test/enhancer/ test/enhancer/sempdept/ test/enhancer/sempdept/src/ test/enhancer/sempdept/src/empdept/ test/fsuid2/ test/fsuid2/org/ test/fsuid2/org/apache/ test/fsuid2/org/apache/jdo/ test/fsuid2/org/apache/jdo/pc/ test/java/ test/java/org/ test/java/org/apache/ test/java/org/apache/jdo/ test/java/org/apache/jdo/impl/ test/java/org/apache/jdo/impl/fostore/ test/java/org/apache/jdo/pc/ test/java/org/apache/jdo/pc/appid/ test/java/org/apache/jdo/pc/empdept/ test/java/org/apache/jdo/pc/serializable/ test/java/org/apache/jdo/pc/xempdept/ test/java/org/apache/jdo/test/ test/java/org/apache/jdo/test/query/ test/java/org/apache/jdo/test/util/ test/jdo/ test/jdo/org/ test/jdo/org/apache/ test/jdo/org/apache/jdo/ test/jdo/org/apache/jdo/pc/ test/jdo/org/apache/jdo/pc/appid/ test/jdo/org/apache/jdo/pc/empdept/ test/jdo/org/apache/jdo/pc/serializable/ test/jdo/org/apache/jdo/pc/xempdept/ xdocs/
Date Sat, 19 Mar 2005 01:06:17 GMT
Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_WeakValueHashMap.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_WeakValueHashMap.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_WeakValueHashMap.java (added)
+++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/Test_WeakValueHashMap.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,572 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed 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.
+ */
+
+/*
+ * TestWeakHashMap.java
+ *
+ */
+
+package org.apache.jdo.test;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.apache.jdo.test.util.AbstractTest;
+import org.apache.jdo.test.util.JDORITestRunner;
+import org.apache.jdo.util.WeakValueHashMap;
+
+/**
+ *
+ * @author Markus Fuchs
+ */
+public class Test_WeakValueHashMap extends AbstractTest {
+
+    static boolean verbose = Boolean.getBoolean("verbose");
+
+    /** */
+    public static void main(String args[]) {
+        JDORITestRunner.run(Test_WeakValueHashMap.class);
+    }
+    
+    /** */
+    protected void setUp() { }
+
+    /** */
+    protected void tearDown()  { }
+
+    /** */
+    public void testContainsKey() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+        y11 = null;
+        y12 = null;
+
+        if (verbose) System.out.println("\nTest ContainsKey:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertTrue("FAILURE: map does not contain x11", map.containsKey(new X("x11", y11)));
+        assertTrue("FAILURE: map does not contain x12", map.containsKey(new X("x12")));
+        assertTrue("FAILURE: map does not contain x13", map.containsKey(new X("x13")));
+        assertTrue("FAILURE: map does not contain x14", map.containsKey(new X("x14")));
+        assertTrue("FAILURE: map does not contain null", map.containsKey(null));
+
+        // now gc
+        gc();
+
+        if (verbose) System.out.println("After GC:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertTrue("FAILURE: map does not contain x11", map.containsKey(new X("x11")));
+        assertTrue("FAILURE: map contains x12", !map.containsKey(new X("x12")));
+        assertTrue("FAILURE: map contains x13", !map.containsKey(new X("x13")));
+        assertTrue("FAILURE: map does not contain x14", map.containsKey(new X("x14")));
+        assertTrue("FAILURE: map does not contain null", map.containsKey(null));
+
+        map.clear();
+    }
+
+    /** */
+    public void testContainsValue() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+        y11 = null;
+        y12 = null;
+
+        if (verbose) System.out.println("\nTest ContainsValue:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertTrue("FAILURE: map does not contain y11", map.containsValue(new Y("y11")));
+        assertTrue("FAILURE: map does not contain y12", map.containsValue(new Y("y12", x12)));
+        assertTrue("FAILURE: map does not contain y13", map.containsValue(new Y("y13")));
+        assertTrue("FAILURE: map does not contain y14", map.containsValue(new Y("y14")));
+        assertTrue("FAILURE: map does not contain null", map.containsValue(new Y("y14")));
+
+        // now gc
+        gc();
+
+        if (verbose) System.out.println("After GC:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertTrue("FAILURE: map does not contain y11", map.containsValue(new Y("y11")));
+        assertTrue("FAILURE: map contains y12", !map.containsValue(new Y("y12", x12)));
+        assertTrue("FAILURE: map contains y13", !map.containsValue(new Y("y13")));
+        assertTrue("FAILURE: map does not contain y14", map.containsValue(new Y("y14")));
+        assertTrue("FAILURE: map does not contain null", map.containsValue(null));
+
+        map.clear();
+    }
+
+    /** */
+    public void testGet() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+
+        if (verbose) System.out.println("\nTest Get:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertEquals("Get (x11) returns wrong value", y11, map.get(new X("x11")));
+        assertEquals("Get (x12) returns wrong value", y12, map.get(new X("x12")));
+        assertEquals("Get (x13) returns wrong value", new Y("y13"), map.get(new X("x13")));
+        assertNull("Get (x14) returns wrong value", map.get(new X("x14")));
+        assertEquals("Get (null) returns wrong value", y14, map.get(null));
+
+        y11 = null;
+        y12 = null;
+
+        // now gc
+        gc();
+
+        if (verbose) System.out.println("After GC:");
+        if (verbose) printEntries(map);
+
+        // check whether instances are included in map
+        assertNotNull("Get (x11) returns wrong value", map.get(new X("x11")));
+        assertNull("Get (x12) returns wrong value",map.get(new X("x12")));
+        assertNull("Get (x13) returns wrong value", map.get(new X("x13")));
+        assertNull("Get (x14) returns wrong value", map.get(new X("x14")));
+        assertNotNull("Get (null) returns wrong value", map.get(null));
+
+        map.clear();
+    }
+
+    /** */
+    public void testSize() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+        y11 = null;
+        y12 = null;
+
+        int size1, size2, size3;
+
+        if (verbose) System.out.println("\nTest Size:");
+        if (verbose) printEntries(map);
+
+        size1 = map.size();
+        size2 = map.entrySet().size();
+        size3 = map.values().size();
+
+        if (verbose) System.out.println("Size: " + size1);
+
+        assertEquals("FAILURE: unexpected size of map", 5, size1); 
+        assertEquals("FAILURE: unexpected size of entrySet", 5, size2); 
+        assertEquals("FAILURE: unexpected size of values", 5, size3); 
+
+        // now gc
+        gc();
+
+        if (verbose) System.out.println("After GC:");
+        if (verbose) printEntries(map);
+
+        size1 = map.size();
+        size2 = map.entrySet().size();
+        size3 = map.values().size();
+
+        if (verbose) System.out.println("After GC, size: " + size1);
+
+        assertEquals("FAILURE: unexpected size of map", 3, size1); 
+        assertEquals("FAILURE: unexpected size of entrySet", 3, size2); 
+        assertEquals("FAILURE: unexpected size of values", 3, size3); 
+
+        map.clear();
+    }
+
+    /** */
+    public void testEntrySet() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+        y11 = null;
+        y12 = null;
+
+        if (verbose) System.out.println("\nTest EntrySet:");
+        if (verbose) printEntries(map);
+
+        Set entrySet = map.entrySet();
+
+        if (verbose) System.out.println("size: " + entrySet.size());
+        assertEquals("Unexpected size of entrySet", 5, entrySet.size());
+        if (verbose) System.out.println("isEmpty: " + entrySet.isEmpty());
+        assertFalse("Unexpected empty entrySet", entrySet.isEmpty());
+        if (verbose) System.out.println("hashCode: " + entrySet.hashCode());
+
+        entrySet.remove(new Entry((Object) x12, (Object) new Y("y12", x12)));
+
+        if (verbose) System.out.println("After remove(x12, y12):");
+        if (verbose) printEntries(map);
+
+        if (verbose) System.out.println("size: " + entrySet.size());
+        assertEquals("Unexpected size of entrySet", 4, entrySet.size());
+        if (verbose) System.out.println("isEmpty: " + entrySet.isEmpty());
+        assertFalse("Unexpected empty entrySet", entrySet.isEmpty());
+        if (verbose) System.out.println("hashCode: " + entrySet.hashCode());
+
+        // Remove a specific entry, then print the map; the entry must be
+        // gone from there.
+        for (Iterator i = entrySet.iterator(); i.hasNext();) {
+            Map.Entry ent = (Map.Entry) i.next();
+            if (ent.getKey() == x11) {
+                i.remove();
+            }                             
+        }
+        
+        if (verbose) System.out.println("After Iterator.remove:");
+        if (verbose) printEntries(map);
+
+        if (verbose) System.out.println("size: " + entrySet.size());
+        assertEquals("Unexpected size of entrySet", 3, entrySet.size());
+        if (verbose) System.out.println("isEmpty: " + entrySet.isEmpty());
+        assertFalse("Unexpected empty entrySet", entrySet.isEmpty());
+        if (verbose) System.out.println("hashCode: " + entrySet.hashCode());
+
+        entrySet.clear();
+        if (verbose) System.out.println("After clear:");
+
+        if (verbose) System.out.println("size: " + entrySet.size());
+        assertEquals("Unexpected size of entrySet", 0, entrySet.size());
+        if (verbose) System.out.println("isEmpty: " + entrySet.isEmpty());
+        assertTrue("Unexpected non empty entrySet", entrySet.isEmpty());
+        if (verbose) System.out.println("hashCode: " + entrySet.hashCode());
+    }
+
+    /** */
+    public void testValues() {
+        Map map = new WeakValueHashMap();
+
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+        y11 = null;
+        y12 = null;
+
+        Collection values = map.values();
+
+        if (verbose) System.out.println("\nTest Values:");
+        if (verbose) printValues(map);
+        assertEquals("Unexpected size of values", 5, values.size());
+
+        // now gc
+        gc();
+
+        if (verbose) System.out.println("After GC:");
+        if (verbose) printValues(map);
+        assertEquals("Unexpected size of values", 3, values.size());
+
+        values.remove(new Y("y11"));
+
+        if (verbose) System.out.println("After remove(y11):");
+        if (verbose) printValues(map);
+        assertEquals("Unexpected size of values", 2, values.size());
+
+        map.clear();
+    }
+
+    /** */
+    public void testAll() {
+        Map weakMap = new WeakValueHashMap();
+
+        // WeakHashMap
+        Y y11 = new Y("y11");
+        X x11 = new X("x11", y11);
+        X x12 = new X("x12");
+        Y y12 = new Y("y12", x12);
+        X x14 = new X("x14");
+        Y y14 = new Y("y14");
+        weakMap.put(x11, y11);
+        weakMap.put(x12, y12);
+        weakMap.put(new X("x13"), new Y("y13"));
+        weakMap.put(x14, null);
+        weakMap.put(null, y14);
+ 
+        // Regular HashMap
+        Map map = new HashMap();
+        map.put(x11, y11);
+        map.put(x12, y12);
+        map.put(new X("x13"), new Y("y13"));
+        map.put(x14, null);
+        map.put(null, y14);
+
+        if (verbose) System.out.println("\nTest equals:");
+        if (verbose) System.out.println("Weak map Map1:"); if (verbose) printEntries(weakMap);
+        if (verbose) System.out.println("Regular map Map2:"); if (verbose) printEntries(map);
+        if (verbose) System.out.println("Map2.equals(Map1): " + map.equals(weakMap));
+        assertTrue("map.equals(weakMap) should return true", map.equals(weakMap));
+        if (verbose) System.out.println("Map1.equals(Map2): " + weakMap.equals(map));
+        assertTrue("weakMap.equals(map) should return true", weakMap.equals(map));
+
+        weakMap.put(new X("x15"), new Y("y15"));
+        map.put(new X("x16"), new Y("y16"));
+
+        if (verbose) System.out.println("\nTest equals:");
+        if (verbose) System.out.println("Weak map Map1:"); if (verbose) printEntries(weakMap);
+        if (verbose) System.out.println("Regular map Map2:"); if (verbose) printEntries(map);
+        if (verbose) System.out.println("Map2.equals(Map1): " + map.equals(weakMap));
+        assertFalse("map.equals(weakMap) should return false", map.equals(weakMap));
+        if (verbose) System.out.println("Map1.equals(Map2): " + weakMap.equals(map));
+        assertFalse("weakMap.equals(map) should return false", weakMap.equals(map));
+
+        weakMap.remove(new X("x15"));
+        map.clear();
+        map.put(new X("x15"), new Y("y15"));
+        map.put(new X("x16"), new Y("y16"));
+
+        if (verbose) System.out.println("\nTest putAll:");
+        if (verbose) System.out.println("Weak map Map1:"); if (verbose) printEntries(weakMap);
+        if (verbose) System.out.println("Regular map Map2:"); if (verbose) printEntries(map);
+        weakMap.putAll(map);
+        if (verbose) System.out.println("Map1.putAll(Map2):"); if (verbose) printEntries(weakMap);
+        assertEquals("Unexpected size of Weak map", 7, weakMap.size());
+        weakMap.remove(new X("x15"));
+        weakMap.remove(new X("x16"));
+
+        if (verbose) System.out.println("\nTest putAll:");
+        if (verbose) System.out.println("Weak map Map1:"); if (verbose) printEntries(weakMap);
+        if (verbose) System.out.println("Regular map Map2:"); if (verbose) printEntries(map);
+        map.putAll(weakMap);
+        if (verbose) System.out.println("Map2.putAll(Map1):"); if (verbose) printEntries(map);
+        assertEquals("Unexpected size of map", 7, map.size());
+
+        weakMap.clear();
+    }
+
+    /* Internal class for entries */
+    private static class Entry implements Map.Entry {
+        private Object key;
+        private Object value;
+
+        Entry(Object key, Object value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public Object getKey() {
+            return key;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Object setValue(Object value) {
+            Object oldValue = this.value;
+            this.value = value;
+            return oldValue;
+        }
+
+        private static boolean valEquals(Object o1, Object o2) {
+            return (o1 == null) ? (o2 == null) : o1.equals(o2);
+        }
+
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry)) return false;
+            Map.Entry e = (Map.Entry) o;
+            return (valEquals(key, e.getKey())
+                    && valEquals(value, e.getValue()));
+        }
+
+        public int hashCode() {
+            Object k;
+            return (((key == null) ? 0 : key.hashCode())
+                    ^ ((value == null) ? 0 : value.hashCode()));
+        }
+
+    }
+
+    private static class X {
+        private String name;
+        private Y y;
+        public X(String name) { this.name = name; }
+        public X(String name, Y y) { this.name = name; this.y = y; }
+        public String toString() { return "(" + this.name + "|" + y + ")"; }
+        public int hashCode() { return (name == null) ? 0 : name.hashCode(); }
+        public boolean equals(Object o)
+        {
+            // compare by name only
+            if ((o == null) || !(o instanceof X))
+                return false;
+            else if (name == null)
+                return ((X)o).name == null;
+            else
+                return name.equals(((X)o).name);
+        }
+    }
+
+    private static class Y implements Comparable {
+        private String name;
+        private X x;
+        public Y(String name) { this.name = name; }
+        public Y(String name, X x) { this.name = name; this.x = x; }
+        public String toString() { return "(" + this.name + "|" + x + ")"; }
+        public int hashCode() { return (name == null) ? 0 : name.hashCode(); }
+        public int compareTo(Object o) {
+            if (o != null
+                && o instanceof Y) {
+                return toString().compareTo(o.toString());
+            } else {
+                return 1;
+            }
+        }            
+        public boolean equals(Object o)
+        {
+            // compare by name only
+            if ((o == null) || !(o instanceof Y))
+                return false;
+            else if (name == null)
+                return ((Y)o).name == null;
+            else
+                return name.equals(((Y)o).name);
+        }
+    }
+
+    /**
+     * A sorted set of instances of map entries.
+     */
+    private static class XTreeSet extends TreeSet {
+        private static final Comparator c = new Comparator() {
+                public int compare(Object o1, Object o2) {
+                    if (o1 == null) {
+                        return -1;
+                    } else if (o2 == null) {
+                        return 1;
+                    } else {
+                        Object s1 = ((Map.Entry)o1).getKey();
+                        Object s2 = ((Map.Entry)o2).getKey();
+                        if (s1 == null) {
+                            return -1;
+                        } else if (s2 == null) {
+                            return 1;
+                        } else {
+                            return (s1.toString()).compareTo(s2.toString());
+                        }
+                    }
+                }
+                
+                public boolean equals(Object obj) {
+                    return obj.equals(this);
+                }
+            };
+        
+        XTreeSet(Collection col) {
+            super(c);
+            this.addAll(col);
+        }
+    }
+
+    private static void printEntries(Map map) {
+        Set entrySet = map.entrySet();
+        TreeSet sorted = new XTreeSet(entrySet);
+        for (Iterator i = sorted.iterator(); i.hasNext();) {
+            Map.Entry ent = (Map.Entry) i.next();
+            System.out.println("Key: " + ent.getKey() +
+                    " Val: " + ent.getValue());
+        }
+    }
+
+    private static void printValues(Map map) {
+        TreeSet values = new TreeSet(map.values());
+        for (Iterator i = values.iterator(); i.hasNext();) {
+            System.out.println("Val: " + i.next());
+        }
+    }
+
+    private static void gc() {
+        //System.out.print("gc: ");
+        Runtime rt = Runtime.getRuntime();
+        long oldfree;
+        long newfree = rt.freeMemory();
+        do {
+            oldfree = newfree;
+            rt.runFinalization(); rt.gc();
+            newfree = rt.freeMemory();
+            //System.out.print('.');
+        } while (newfree > oldfree);
+        //System.out.println();
+    }
+
+}
+
+

Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/AdvancedTest.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/AdvancedTest.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/AdvancedTest.java (added)
+++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/AdvancedTest.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,1856 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed 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.
+ */
+
+/*
+ * AdvancedTest.java
+ *
+ * Created on April 10, 2000
+ */
+
+package org.apache.jdo.test.query;
+
+import java.util.*;
+import java.io.*;
+import java.io.PrintStream;
+
+import javax.jdo.*;
+
+import org.apache.jdo.pc.xempdept.Department;
+import org.apache.jdo.pc.xempdept.Employee;
+import org.apache.jdo.pc.xempdept.PrimitiveTypes;
+import org.apache.jdo.pc.xempdept.Project;
+
+/** 
+ *
+ * @author  Michael Bouschen
+ */
+public class AdvancedTest
+    extends PositiveTest
+{
+    public AdvancedTest(PersistenceManagerFactory pmf, PrintStream log)
+    {
+        super(pmf, log);
+    }
+
+    protected boolean isTestMethodName(String methodName)
+    {
+       return methodName.startsWith("advanced");
+    }
+
+    // ==========================================================================
+    // Test methods
+    // ==========================================================================
+
+    /**
+     * Testcase: check for null values ==
+     */
+    public void advanced001()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname == null");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+
+    /**
+     * Testcase: check for null values !=
+     */
+    public void advanced002()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname != null");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 8;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+
+    /**
+     * Testcase: serialize/deserialize non compiled query
+     */
+    public void advanced003()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("empid == 3");
+        setEmployeeCandidates(query);
+       
+        // serialize query object
+        ByteArrayOutputStream bout = new ByteArrayOutputStream ();
+        ObjectOutputStream oout = new ObjectOutputStream (bout);
+        oout.writeObject (query);
+        oout.flush ();
+        byte[] bytes = bout.toByteArray();
+        oout.close ();
+
+        // deserialize query object
+        ByteArrayInputStream bin = new ByteArrayInputStream (bytes);
+        ObjectInputStream oin = new ObjectInputStream (bin);
+        query = (Query)oin.readObject ();
+        oin.close ();
+
+        // init and execute query
+        query = pm.newQuery(query);
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+
+    /**
+     * Testcase: serialize/deserialize compiled query
+     * checks bug report 4518967
+     */
+    public void advanced004()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("empid == 3");
+        setEmployeeCandidates(query);
+        query.compile();
+       
+        // serialize query object
+        ByteArrayOutputStream bout = new ByteArrayOutputStream ();
+        ObjectOutputStream oout = new ObjectOutputStream (bout);
+        oout.writeObject (query);
+        oout.flush ();
+        byte[] bytes = bout.toByteArray();
+        oout.close ();
+
+        // deserialize query object
+        ByteArrayInputStream bin = new ByteArrayInputStream (bytes);
+        ObjectInputStream oin = new ObjectInputStream (bin);
+        query = (Query)oin.readObject ();
+        oin.close ();
+
+        // init and execute query
+        query = pm.newQuery(query);
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+
+    /**
+     * Testcase: serialize/deserialize compiled query 
+     * (using more compilated query)
+     * checks bug report 4518967
+     */
+    public void advanced005()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.declareParameters("Project p");
+        query.declareVariables("Project project");
+        query.setFilter("projects.contains(project) & project.projid == p.projid");
+        setEmployeeCandidates(query);
+        query.compile();
+       
+        // serialize query object
+        ByteArrayOutputStream bout = new ByteArrayOutputStream ();
+        ObjectOutputStream oout = new ObjectOutputStream (bout);
+        oout.writeObject (query);
+        oout.flush ();
+        byte[] bytes = bout.toByteArray();
+        oout.close ();
+
+        // deserialize query object
+        ByteArrayInputStream bin = new ByteArrayInputStream (bytes);
+        ObjectInputStream oin = new ObjectInputStream (bin);
+        query = (Query)oin.readObject ();
+        oin.close ();
+
+        // init and execute query
+        Project p = getProjectById(1L);
+        
+        query = pm.newQuery(query);
+        setEmployeeCandidates(query);
+        Object result = query.execute(p);
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+
+    /**
+     * Testcase: re-execute the same query w/o recompile
+     * checks bug report 4349720
+     */
+    public void advanced006()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("empid == 6");;
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        // rexecute the query
+
+        result = query.execute();
+        oids = getResultOids(result);
+
+        // check new query result
+
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: use ESCuxxxx chars in string literal
+     */
+    public void advanced007()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname == \"\u0066irstEngOne\"");;
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: use ESCxxx chars in string literal
+     */
+    public void advanced008()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname == \"\146irstEngOne\"");;
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: wildcard queries startsWith
+     */
+    public void advanced009()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname.startsWith(\"firstEng\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries endsWith
+     */
+    public void advanced010()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname.endsWith(\"e\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries startsWith with non constant arguments
+     */
+    public void advanced011()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname.startsWith(\"first\" + department.name)");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries endsWith with non constant arguments
+     */
+    public void advanced012()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("firstname.endsWith(department.name + \"Five\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries startsWith with simple navigation
+     * checks bug report 4418353
+     */
+    public void advanced015()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("department.name.startsWith(\"Eng\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries endsWith with simple navigation
+     * checks bug report 4418353
+     */
+    public void advanced016()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("department.name.endsWith(\"ing\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: wildcard queries startsWith with collection navigation
+     * checks bug report 4418353
+     */
+    public void advanced017()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.declareImports("import org.apache.jdo.pc.xempdept.Project");
+        query.declareVariables("Project p");
+        query.setFilter("projects.contains(p) & p.name.startsWith(\"E\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+    /**
+     * Testcase: wildcard queries endsWith with collection navigation
+     * checks bug report 4418353
+     */
+    public void advanced018()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.declareImports("import org.apache.jdo.pc.xempdept.Project");
+        query.declareVariables("Project p");
+        query.setFilter("projects.contains(p) & p.name.endsWith(\"g Project\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: no filter specified
+     */
+    public void advanced019()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: filter specified as empty string
+     */
+    public void advanced020()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("  ");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize boolean constant == boolean constant
+     */
+    public void advanced021()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("true == !true");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize boolean constant != boolean constant
+     */
+    public void advanced022()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("true != (employees == null)");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize boolean constant == expr
+     */
+    public void advanced023()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("true == (empid == 1)");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize expr == boolean constant
+     * checks bug report 4444393
+     */
+    public void advanced024()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("employees.isEmpty() == false");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize boolean constant != expr
+     */
+    public void advanced025()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("false != firstname.startsWith(\"firstEng\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize expr != boolean constant
+     */
+    public void advanced026()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("employees.isEmpty() != true");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize expr && true
+     */
+    public void advanced027()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("(empid == 1) && true");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize expr & false
+     */
+    public void advanced028()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("lastname.endsWith(\"bla\") & false");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: true & expr
+     */
+    public void advanced029()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("true & team.isEmpty()");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: false && expr
+     */
+    public void advanced030()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("(team == null) && (empid == 1)");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    /**
+     * Testcase: optimize expr | true
+     */
+    public void advanced031()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("!employees.isEmpty() | true");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: optimize expr || false
+     */
+    public void advanced032()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("(empid == 1) || false");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: true || expr
+     */
+    public void advanced033()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("true || firstname.startsWith(\"bla\")");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 4;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 6;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 8;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+    
+    /**
+     * Testcase: false | expr
+     */
+    public void advanced034()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("false | (empid == 2)");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: !true
+     */
+    public void advanced035()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("!true");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: invert inner equality comparison, 
+     * because of outer equality comparison with constant
+     */
+    public void advanced036()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("(empid != 1) == false");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: invert inner logical not, 
+     * because of outer equality comparison with constant
+     */
+    public void advanced037()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("!team.isEmpty() == false");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 3;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 5;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 7;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: multiple boolean constant expressions
+     */
+    public void advanced038()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter(" ((empid == 1) && !(false)) | (false && true) || ((empid == 2) == true)");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 1;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 2;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: optimize constant == constant for non boolean constants
+     * checks bug report 4481691
+     */
+    public void advanced039()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("1 == 1");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        Department.Oid key = new Department.Oid();
+        key.deptid = 1;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 2;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 3;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 4;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 11;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 12;
+        expected.add(key);
+        key = new Department.Oid();
+        key.deptid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: optimize constant != constant for non boolean constants 
+     * checks bug report 4481691
+     */
+    public void advanced040()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Department.class);
+        query.setFilter("1 != 1");
+        setDepartmentCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+
+    /**
+     * Testcase: Method getPersistenceManager should return null 
+     * if called for a deserialized, unbound query object.
+     * checks bug report 4547932
+     */
+    public void advanced041()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("empid == 3");
+        
+        // serialize query object
+        ByteArrayOutputStream bout = new ByteArrayOutputStream ();
+        ObjectOutputStream oout = new ObjectOutputStream (bout);
+        oout.writeObject (query);
+        oout.flush ();
+        byte[] bytes = bout.toByteArray();
+        oout.close ();
+
+        // deserialize query object
+        ByteArrayInputStream bin = new ByteArrayInputStream (bytes);
+        ObjectInputStream oin = new ObjectInputStream (bin);
+        query = (Query)oin.readObject ();
+        oin.close ();
+
+        PersistenceManager otherPM = query.getPersistenceManager();
+        if (otherPM != null)
+            throw new Exception("Expected null PM for deserialized, unbound query object, pm == " + pm);
+        tx.commit();
+    }
+
+    /**
+     * Testcase: filter uses boolean fields (booleanField == true)
+     */
+    public void advanced042()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("booleanNull == true");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 1;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 3;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 5;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 11;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: use of hex literal
+     * checks bug report 4818832
+     */
+    public void advanced043()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("intNotNull == 0x7fffffff");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 10;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: use of oct literal
+     * checks bug report 4818832
+     */
+    public void advanced044()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        // create query
+        
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("intNotNull == 017777777777");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 10;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: filter using Integer.MIN_VALUE
+     * checks bug report 4818832
+     */
+    public void advanced045()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("longNotNull == -2147483648");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+
+        Collection expected = new ArrayList();
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: navigation through a null valued relationship field.
+     * checks bug report 4833898
+     */
+    public void advanced046()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("this.department.deptid > 3 || this.empid == 100");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 8;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: navigation through a null valued relationship field.
+     * checks bug report 4833898
+     */
+    public void advanced047()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(Employee.class);
+        query.setFilter("this.empid == 100 | this.department.deptid > 3");
+        setEmployeeCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+
+        // check query result
+
+        Collection expected = new ArrayList();
+        Employee.Oid key = new Employee.Oid();
+        key.empid = 8;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 9;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 11;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 12;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 13;
+        expected.add(key);
+        key = new Employee.Oid();
+        key.empid = 100;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+}
+

Added: incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/ArithmeticTest.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/ArithmeticTest.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/ArithmeticTest.java (added)
+++ incubator/jdo/trunk/ri11/test/java/org/apache/jdo/test/query/ArithmeticTest.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,324 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed 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.
+ */
+
+/*
+ * ArithmeticTest.java
+ *
+ * Created on April 10, 2000
+ */
+
+package org.apache.jdo.test.query;
+
+import java.util.*;
+import java.io.PrintStream;
+
+import javax.jdo.*;
+
+import org.apache.jdo.pc.xempdept.PrimitiveTypes;
+
+/** 
+ *
+ * @author  Michael Bouschen
+ */
+public class ArithmeticTest
+    extends PositiveTest
+{
+    public ArithmeticTest(PersistenceManagerFactory pmf, PrintStream log)
+    {
+        super(pmf, log);
+    }
+
+    protected boolean isTestMethodName(String methodName)
+    {
+        return methodName.startsWith("arithmetic");
+    }
+
+    // ==========================================================================
+    // Test methods
+    // ==========================================================================
+    
+    /**
+     * Testcase: arithmetic operation 
+     * field == literal + literal
+     */
+    public void arithmetic001()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+        
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("intNotNull == ( 1 + 2 )");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 3;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: arithmetic operation 
+     * field - literal > literal
+     */
+    public void arithmetic002()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("floatNotNull - 10000.0 > 10000.0");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 14;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: arithmetic operation 
+     * field * literal > literal
+     */
+    public void arithmetic003()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("doubleNotNull * 10 > 45.0");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 5;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 14;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: arithmetic operation 
+     * field / literal < literal
+     */
+    public void arithmetic004()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("doubleNull > 0.0 && (doubleNull / 10.0 < 0.5)");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 1;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 2;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 3;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 4;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 10;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 12;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: unary operation +
+     */
+    public void arithmetic005()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("+byteNotNull == 1");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: unary operation -
+     * check bug report 4437010
+     */
+    public void arithmetic006()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("-byteNull == -1");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+
+    /**
+     * Testcase: complement operation ~
+     */
+    public void arithmetic007()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("~shortNotNull == -2");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 1;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+
+        tx.commit();
+    }
+ 
+   /**
+     * Testcase: string concatenation operator +
+     */
+    public void arithmetic008()
+        throws Exception
+    {
+        Transaction tx = pm.currentTransaction();
+        tx.begin();
+        
+        // create and execute query
+        Query query = pm.newQuery();
+        query.setClass(PrimitiveTypes.class);
+        query.setFilter("stringNull == \"yet \" + \"another string\"");
+        setPrimitiveTypesCandidates(query);
+        Object result = query.execute();
+        List oids = getResultOids(result);
+        Collections.sort(oids);
+        
+        // check query result
+        
+        Collection expected = new ArrayList();
+        PrimitiveTypes.Oid key = new PrimitiveTypes.Oid();
+        key.id = 12;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 13;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 14;
+        expected.add(key);
+        key = new PrimitiveTypes.Oid();
+        key.id = 15;
+        expected.add(key);
+        checkQueryResult(oids, expected);
+        
+        tx.commit();
+    }
+    
+}
+



Mime
View raw message