Menu
▾
▴
[Bigdata-commit] SF.net SVN: bigdata:[3578] branches/QUADS_QUERY_BRANCH/bigdata/src
|
From: <dm...@us...> - 2010-09-17 11:22:36
|
Revision: 3578
http://bigdata.svn.sourceforge.net/bigdata/?rev=3578&view=rev
Author: dmacgbr
Date: 2010-09-17 11:22:28 +0000 (Fri, 17 Sep 2010)
Log Message:
-----------
Add some unit tests
Modified Paths:
--------------
branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/ArrayBindingSet.java
branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/HashBindingSet.java
branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/solutions/MemorySortOp.java
branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestAll.java
branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/solutions/TestMemorySortOp.java
Added Paths:
-----------
branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestArrayBindingSet.java
branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestHashBindingSet.java
branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestIBindingSet.java
Modified: branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/ArrayBindingSet.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/ArrayBindingSet.java 2010-09-17 10:44:01 UTC (rev 3577)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/ArrayBindingSet.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -435,10 +435,8 @@
for(int i=0; i<nbound; i++) {
-// if (!o.isBound(vars[i]))
-// return false;
-
- if (!vals[i].equals(o.get(vars[i])))
+ IConstant<?> o_val = o.get ( vars [ i ] ) ;
+ if ( null == o_val || !vals[i].equals( o_val ))
return false;
}
Modified: branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/HashBindingSet.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/HashBindingSet.java 2010-09-17 10:44:01 UTC (rev 3577)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/HashBindingSet.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -283,8 +283,8 @@
// if (!o.isBound(vars[i]))
// return false;
-
- if (!val.equals(o.get(var)))
+ IConstant<?> o_val = o.get ( var ) ;
+ if (null == o_val || !val.equals(o_val))
return false;
}
Modified: branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/solutions/MemorySortOp.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/solutions/MemorySortOp.java 2010-09-17 10:44:01 UTC (rev 3577)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/java/com/bigdata/bop/solutions/MemorySortOp.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -88,10 +88,6 @@
// sort.
Arrays.sort(all, comparator);
- // update counters.
- stats.unitsOut.add(all.length);
- stats.chunksOut.increment();
-
// write output and flush.
sink.add(all);
sink.flush();
Modified: branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestAll.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestAll.java 2010-09-17 10:44:01 UTC (rev 3577)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestAll.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -65,7 +65,8 @@
suite.addTestSuite(TestConstant.class);
// test binding set impls.
- suite.addTestSuite(TestBindingSet.class);
+ suite.addTestSuite(TestArrayBindingSet.class);
+ suite.addTestSuite(TestHashBindingSet.class);
// unit tests for ctor existence and deep copy semantics
suite.addTestSuite(TestDeepCopy.class);
Added: branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestArrayBindingSet.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestArrayBindingSet.java (rev 0)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestArrayBindingSet.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -0,0 +1,110 @@
+/*
+
+Copyright (C) SYSTAP, LLC 2006-2008. All rights reserved.
+
+Contact:
+ SYSTAP, LLC
+ 4501 Tower Road
+ Greensboro, NC 27410
+ lic...@bi...
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*/
+/*
+ * Created on Jun 19, 2008
+ */
+
+package com.bigdata.bop;
+
+
+/**
+ * Unit tests for {@link ArrayBindingSet}.
+ *
+ * Note:
+ * a) these tests assume that the values held for a given key are not cloned,
+ * i.e. comparison is done by '==' and not '.equals'
+ * b) keys with the same 'name' are a unique object.
+ *
+ * @author <a href="mailto:dm...@us...">David MacMillan</a>
+ * @version $Id$
+ */
+public class TestArrayBindingSet extends TestIBindingSet
+{
+ /**
+ *
+ */
+ public TestArrayBindingSet () {}
+
+ /**
+ * @param name
+ */
+ public TestArrayBindingSet ( String name ) { super ( name ) ; }
+
+ /**
+ * Unit test for {@link ArrayBindingSet#ArrayBindingSet(ArrayBindingSet)}
+ */
+ public void testConstructorArrayBindingSet ()
+ {
+ try { assertTrue ( null != new ArrayBindingSet ( null ) ) ; fail ( "IllegalArgumentException expected, copy from was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ IVariable<?> vars [] = new IVariable [] { var1, var2 } ;
+ IConstant<?> vals [] = new IConstant [] { val1, val2 } ;
+
+ assertEqual ( new ArrayBindingSet ( new ArrayBindingSet ( vars, vals ) ), vars, vals ) ;
+ }
+
+ /**
+ * Unit test for {@link ArrayBindingSet#ArrayBindingSet(IVariable[],IConstant[])}
+ */
+ public void testConstructorVariablesConstants ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ IVariable<?> vars [] = new IVariable [] { var1, var2 } ;
+ IConstant<?> vals [] = new IConstant [] { val1, val2 } ;
+
+ try { assertTrue ( null != new ArrayBindingSet ( null, vals ) ) ; fail ( "IllegalArgumentException expected, vars was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ try { assertTrue ( null != new ArrayBindingSet ( vars, null ) ) ; fail ( "IllegalArgumentException expected, vals was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ try { assertTrue ( null != new ArrayBindingSet ( vars, new IConstant [] { val1 } ) ) ; fail ( "IllegalArgumentException expected, vars and vals were different sizes" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ assertEqual ( new ArrayBindingSet ( vars, vals ), vars, vals ) ;
+ }
+
+ /**
+ * Unit test for {@link ArrayBindingSet#ArrayBindingSet(int)}
+ */
+ public void testConstructorInt ()
+ {
+ try { assertTrue ( null != new ArrayBindingSet ( -1 ) ) ; fail ( "IllegalArgumentException expected, capacity was negative" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ assertEqual ( new ArrayBindingSet ( 2 ), new IVariable [] {}, new IConstant [] {} ) ;
+ }
+
+ @Override protected IBindingSet newBindingSet ( IVariable<?> vars [], IConstant<?> vals [] ) { return new ArrayBindingSet ( vars, vals ) ; }
+ @Override protected IBindingSet newBindingSet ( int size ) { return new ArrayBindingSet ( size ) ; }
+}
\ No newline at end of file
Added: branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestHashBindingSet.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestHashBindingSet.java (rev 0)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestHashBindingSet.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -0,0 +1,128 @@
+/*
+
+Copyright (C) SYSTAP, LLC 2006-2008. All rights reserved.
+
+Contact:
+ SYSTAP, LLC
+ 4501 Tower Road
+ Greensboro, NC 27410
+ lic...@bi...
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*/
+/*
+ * Created on Jun 19, 2008
+ */
+
+package com.bigdata.bop;
+
+
+/**
+ * Unit tests for {@link HashBindingSet}.
+ *
+ * Note:
+ * a) these tests assume that the values held for a given key are not cloned,
+ * i.e. comparison is done by '==' and not '.equals'
+ * b) keys with the same 'name' are a unique object.
+ *
+ * @author <a href="mailto:dm...@us...">David MacMillan</a>
+ * @version $Id$
+ */
+public class TestHashBindingSet extends TestIBindingSet
+{
+
+ /**
+ *
+ */
+ public TestHashBindingSet () {}
+
+ /**
+ * @param name
+ */
+ public TestHashBindingSet ( String name ) { super ( name ) ; }
+
+ /**
+ * Unit test for {@link HashBindingSet#HashBindingSet()}
+ */
+ public void testConstructorHashBindingSet ()
+ {
+ assertTrue ( null != new HashBindingSet () ) ;
+ }
+
+ /**
+ * Unit test for {@link HashBindingSet#HashBindingSet(HashBindingSet)}
+ */
+ public void testConstructorHashBindingSetHashBindingSet ()
+ {
+ // TODO what is our philosophy on argument validation?
+// try { assertTrue ( null != new HashBindingSet ( null ) ) ; fail ( "IllegalArgumentException expected, copy from was null" ) ; }
+// catch ( IllegalArgumentException e ) {}
+
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ IVariable<?> vars [] = new IVariable [] { var1, var2 } ;
+ IConstant<?> vals [] = new IConstant [] { val1, val2 } ;
+
+ assertEqual ( new HashBindingSet ( new HashBindingSet ( vars, vals ) ), vars, vals ) ;
+ }
+
+ /**
+ * Unit test for {@link HashBindingSet#HashBindingSet(IBindingSet)}
+ */
+ public void testConstructorHashBindingSetIBindingSet ()
+ {
+ // TODO what is our philosophy on argument validation?
+// try { assertTrue ( null != new HashBindingSet ( null ) ) ; fail ( "IllegalArgumentException expected, copy from was null" ) ; }
+// catch ( IllegalArgumentException e ) {}
+
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ IVariable<?> vars [] = new IVariable [] { var1, var2 } ;
+ IConstant<?> vals [] = new IConstant [] { val1, val2 } ;
+
+ assertEqual ( new HashBindingSet ( new ArrayBindingSet ( vars, vals ) ), vars, vals ) ;
+ }
+
+ /**
+ * Unit test for {@link HashBindingSet#HashBindingSet(IVariable[],IConstant[])}
+ */
+ public void testConstructorVariablesConstants ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ IVariable<?> vars [] = new IVariable [] { var1, var2 } ;
+ IConstant<?> vals [] = new IConstant [] { val1, val2 } ;
+
+ try { assertTrue ( null != new HashBindingSet ( null, vals ) ) ; fail ( "IllegalArgumentException expected, vars was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ try { assertTrue ( null != new HashBindingSet ( vars, null ) ) ; fail ( "IllegalArgumentException expected, vals was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ try { assertTrue ( null != new HashBindingSet ( vars, new IConstant [] { val1 } ) ) ; fail ( "IllegalArgumentException expected, vars and vals were different sizes" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ assertEqual ( new HashBindingSet ( vars, vals ), vars, vals ) ;
+ }
+
+ @Override protected IBindingSet newBindingSet ( IVariable<?> vars [], IConstant<?> vals [] ) { return new HashBindingSet ( vars, vals ) ; }
+ @Override protected IBindingSet newBindingSet ( int size ) { return new HashBindingSet () ; }
+}
\ No newline at end of file
Added: branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestIBindingSet.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestIBindingSet.java (rev 0)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/TestIBindingSet.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -0,0 +1,327 @@
+/*
+
+Copyright (C) SYSTAP, LLC 2006-2008. All rights reserved.
+
+Contact:
+ SYSTAP, LLC
+ 4501 Tower Road
+ Greensboro, NC 27410
+ lic...@bi...
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*/
+/*
+ * Created on Jun 19, 2008
+ */
+
+package com.bigdata.bop;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import junit.framework.TestCase2;
+
+/**
+ * Unit tests for {@link IBindingSet}.
+ *
+ * Note:
+ * a) these tests assume that the values held for a given key are not cloned,
+ * i.e. comparison is done by '==' and not '.equals'
+ * b) keys with the same 'name' are a unique object.
+ *
+ * @author <a href="mailto:dm...@us...">David MacMillan</a>
+ * @version $Id$
+ */
+public abstract class TestIBindingSet extends TestCase2 {
+
+ /**
+ *
+ */
+ public TestIBindingSet () {}
+
+ /**
+ * @param name
+ */
+ public TestIBindingSet ( String name ) { super ( name ) ; }
+
+ /**
+ * Unit test for {@link IBindingSet#isBound(IVariable)}
+ */
+ public void testIsBound ()
+ {
+ Var<?> a = Var.var ( "a" ) ;
+ Var<?> b = Var.var ( "b" ) ;
+ Var<?> c = Var.var ( "a" ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { a }, new IConstant [] { new Constant<Integer> ( 1 ) } ) ;
+
+ assertTrue ( "bound expected, same variable", bs.isBound ( a ) ) ;
+ assertFalse ( "not bound expected", bs.isBound ( b ) ) ;
+ assertTrue ( "bound expected, equivalent variable", bs.isBound ( c ) ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#set(IVariable,IConstant)}
+ */
+ public void testSet ()
+ {
+ Var<?> var = Var.var ( "a" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( 2 ) ;
+
+ try { bs.set ( null, val1 ) ; fail ( "IllegalArgumentException expected, var was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ try { bs.set ( var, null ) ; fail ( "IllegalArgumentException expected, val was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ bs.set ( var, val1 ) ;
+ assertTrue ( val1 == bs.get ( var ) ) ;
+
+ bs.set ( var, val2 ) ;
+ assertTrue ( val2 == bs.get ( var ) ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#get(IVariable)}
+ */
+ public void testGet ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1 }, new IConstant [] { val1 } ) ;
+
+ try { bs.get ( null ) ; fail ( "IllegalArgumentException expected, var was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ assertTrue ( val1 == bs.get ( var1 ) ) ;
+ assertTrue ( null == bs.get ( var2 ) ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#clear(IVariable)}
+ */
+ public void testClear ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+
+ try { bs.clear ( null ) ; fail ( "IllegalArgumentException expected, var was null" ) ; }
+ catch ( IllegalArgumentException e ) {}
+
+ bs.clear ( var1 ) ;
+ assertTrue ( null == bs.get ( var1 ) ) ;
+ assertTrue ( val2 == bs.get ( var2 ) ) ;
+
+ bs.clear ( var2 ) ;
+ assertTrue ( null == bs.get ( var2 ) ) ;
+ assertTrue ( 0 == bs.size () ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#clearAll()}
+ */
+ public void testClearAll ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+
+ bs.clearAll () ;
+ assertTrue ( null == bs.get ( var1 ) ) ;
+ assertTrue ( null == bs.get ( var2 ) ) ;
+ assertTrue ( 0 == bs.size () ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#size()}
+ */
+ public void testSize ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( 2 ) ;
+
+ assertTrue ( 0 == bs.size () ) ;
+
+ bs.set ( var1, val1 ) ;
+ bs.set ( var2, val2 ) ;
+ assertTrue ( 2 == bs.size () ) ;
+
+ bs.clear ( var2 ) ;
+ assertTrue ( 1 == bs.size () ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#iterator()}
+ */
+ public void testIterator ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+
+ int n = 0 ;
+ for ( Iterator<Map.Entry<IVariable,IConstant>> i = bs.iterator (); i.hasNext (); )
+ {
+ Map.Entry<IVariable,IConstant> e = i.next () ;
+ IVariable<?> var = e.getKey () ;
+
+ if ( var1 == var ) assertTrue ( "wrong value", val1 == e.getValue () ) ;
+ else if ( var2 == var ) assertTrue ( "wrong value", val2 == e.getValue () ) ;
+ else fail ( "unexpected variable: " + var ) ;
+
+ try { i.remove () ; fail ( "UnsupportedOperationException expected, iterator remove" ) ; }
+ catch ( UnsupportedOperationException ex ) {}
+ n++ ;
+ }
+ assertTrue ( "wrong count", 2 == n ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#vars()}
+ */
+ public void testVars ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+
+ int n = 0 ;
+ for ( Iterator<IVariable> i = bs.vars (); i.hasNext (); )
+ {
+ IVariable<?> var = i.next () ;
+
+ if ( var1 != var && var2 != var )
+ fail ( "unexpected variable: " + var ) ;
+
+ try { i.remove () ; fail ( "UnsupportedOperationException expected, iterator remove" ) ; }
+ catch ( UnsupportedOperationException e ) {}
+ n++ ;
+ }
+ assertTrue ( "wrong count", 2 == n ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#copy(IVariable[])}
+ */
+ public void testCopy ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Var<?> var3 = Var.var ( "c" ) ;
+ Var<?> var4 = Var.var ( "d" ) ;
+ Var<?> var5 = Var.var ( "e" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ Constant<Integer> val3 = new Constant<Integer> ( 3 ) ;
+ Constant<Integer> val4 = new Constant<Integer> ( 4 ) ;
+ Constant<Integer> val5 = new Constant<Integer> ( 5 ) ;
+
+ IBindingSet bs = newBindingSet ( new IVariable [] { var1, var2, var3, var4, var5 }
+ , new IConstant [] { val1, val2, val3, val4, val5 }
+ ) ;
+
+ IBindingSet bs2 = bs.copy ( new IVariable [] { var1, var3, var5 } ) ;
+
+ assertTrue ( 3 == bs2.size () ) ;
+ for ( IVariable<?> v : new IVariable [] { var1, var3, var5 } )
+ assertTrue ( bs2.get ( v ).equals ( bs.get ( v ) ) ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#equals(Object)}
+ */
+ public void testEquals ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Var<?> var3 = Var.var ( "c" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+ Constant<Integer> val3 = new Constant<Integer> ( 3 ) ;
+
+ IBindingSet bs1 = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+ IBindingSet bs2 = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+ IBindingSet bs3 = newBindingSet ( new IVariable [] { var2, var1 }, new IConstant [] { val2, val1 } ) ;
+ IBindingSet bs4 = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val3 } ) ;
+ IBindingSet bs5 = newBindingSet ( new IVariable [] { var1, var3 }, new IConstant [] { val1, val3 } ) ;
+ IBindingSet bs6 = newBindingSet ( new IVariable [] { var1, var2, var3 }, new IConstant [] { val1, val2, val3 } ) ;
+ IBindingSet bs7 = newBindingSet ( new IVariable [] { var1 }, new IConstant [] { val1 } ) ;
+
+ assertTrue ( "expected equal: same bindings, same order", bs1.equals ( bs2 ) ) ;
+ assertTrue ( "expected equal: same bindings, different order", bs1.equals ( bs3 ) ) ;
+ assertTrue ( "expected not equal: different value", !bs1.equals ( bs4 ) ) ;
+ assertTrue ( "expected not equal: different variable", !bs1.equals ( bs5 ) ) ;
+ assertTrue ( "expected not equal: subsetOf ( this, that )", !bs1.equals ( bs6 ) ) ;
+ assertTrue ( "expected not equal: subsetOf ( that, this )", !bs1.equals ( bs7 ) ) ;
+ }
+
+ /**
+ * Unit test for {@link IBindingSet#hashCode()}
+ */
+ public void testHashCode ()
+ {
+ Var<?> var1 = Var.var ( "a" ) ;
+ Var<?> var2 = Var.var ( "b" ) ;
+ Constant<Integer> val1 = new Constant<Integer> ( 1 ) ;
+ Constant<Integer> val2 = new Constant<Integer> ( 2 ) ;
+
+ IBindingSet bs1 = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+ IBindingSet bs2 = newBindingSet ( new IVariable [] { var1, var2 }, new IConstant [] { val1, val2 } ) ;
+ IBindingSet bs3 = newBindingSet ( new IVariable [] { var2, var1 }, new IConstant [] { val2, val1 } ) ;
+ IBindingSet bs4 = newBindingSet ( new IVariable [] { var2 }, new IConstant [] { val2 } ) ;
+
+ assertTrue ( "expected equal: same bindings, same order", bs1.hashCode () == bs2.hashCode () ) ;
+ assertTrue ( "expected equal: same bindings, different order", bs1.hashCode () == bs3.hashCode () ) ;
+
+ //
+ // After mutation. Not sure that this really proves anything, although in most cases I guess that
+ // the original value of bs1.hasCode () will not equal the subsequent value or that of bs4.hashCode ()
+ //
+ bs1.clear ( var1 ) ;
+ assertTrue ( "expected equal: same bindings after mutation", bs1.hashCode () == bs4.hashCode () ) ;
+ }
+
+ protected abstract IBindingSet newBindingSet ( IVariable<?> vars [], IConstant<?> vals [] ) ;
+ protected abstract IBindingSet newBindingSet ( int size ) ;
+
+ protected void assertEqual ( IBindingSet actual, IVariable<?> vars [], IConstant<?> vals [] )
+ {
+ assertTrue ( "wrong size", actual.size () == vars.length ) ;
+ for ( int i = 0; i < vars.length; i++ )
+ assertTrue ( "wrong value", vals [ i ] == actual.get ( vars [ i ] ) ) ;
+ }
+}
\ No newline at end of file
Modified: branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/solutions/TestMemorySortOp.java
===================================================================
--- branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/solutions/TestMemorySortOp.java 2010-09-17 10:44:01 UTC (rev 3577)
+++ branches/QUADS_QUERY_BRANCH/bigdata/src/test/com/bigdata/bop/solutions/TestMemorySortOp.java 2010-09-17 11:22:28 UTC (rev 3578)
@@ -27,11 +27,24 @@
package com.bigdata.bop.solutions;
-import com.bigdata.bop.solutions.ISortOrder;
-import com.bigdata.bop.solutions.MemorySortOp;
-
import junit.framework.TestCase2;
+import com.bigdata.bop.ArrayBindingSet;
+import com.bigdata.bop.BOp;
+import com.bigdata.bop.BOpContext;
+import com.bigdata.bop.Constant;
+import com.bigdata.bop.IBindingSet;
+import com.bigdata.bop.IConstant;
+import com.bigdata.bop.IVariable;
+import com.bigdata.bop.NV;
+import com.bigdata.bop.Var;
+import com.bigdata.bop.engine.BOpStats;
+import com.bigdata.bop.engine.MockRunningQuery;
+import com.bigdata.bop.engine.TestQueryEngine;
+import com.bigdata.relation.accesspath.IAsynchronousIterator;
+import com.bigdata.relation.accesspath.IBlockingBuffer;
+import com.bigdata.relation.accesspath.ThickAsynchronousIterator;
+
/**
* Unit tests for the {@link MemorySortOp}.
*
@@ -43,26 +56,137 @@
/**
*
*/
- public TestMemorySortOp() {
- }
+ public TestMemorySortOp () {}
/**
* @param name
*/
- public TestMemorySortOp(String name) {
- super(name);
+ public TestMemorySortOp ( String name )
+ {
+ super ( name ) ;
}
- /**
- * @todo unit tests for the in-memory sort operator. These tests should not
- * focus on SPARQL semantics. Instead, just test the ability to impose
- * the appropriate {@link ISortOrder}[] on some in-memory binding
- * sets.
- */
- public void test_something() {
+ public void testEval ()
+ {
+ IVariable<?> x = Var.var ( "x" ) ;
+ IVariable<?> y = Var.var ( "y" ) ;
+ IConstant<String> a = new Constant<String> ( "a" ) ;
+ IConstant<String> b = new Constant<String> ( "b" ) ;
+ IConstant<String> c = new Constant<String> ( "c" ) ;
+ IConstant<String> d = new Constant<String> ( "d" ) ;
+ IConstant<String> e = new Constant<String> ( "e" ) ;
- fail("write tests");
+ ISortOrder<?> sors [] = new ISortOrder [] { new SortOrder ( x, true ), new SortOrder ( y, false ) } ;
+
+ SortOp query = new MemorySortOp ( new BOp [] {}
+ , NV.asMap ( new NV [] { new NV ( MemorySortOp.Annotations.BOP_ID, 1 )
+ , new NV ( MemorySortOp.Annotations.COMPARATOR, new StringComparatorOp ( sors ) )
+ }
+ )
+ ) ;
+
+ //
+ // the test data
+ //
+ IBindingSet data [] = new IBindingSet []
+ {
+ new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, a } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, e } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x }, new IConstant [] { c } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { d, a } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { d, b } )
+ , new ArrayBindingSet ( new IVariable<?> [] {}, new IConstant [] {} )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, c } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { b, d } )
+ , new ArrayBindingSet ( new IVariable<?> [] { y }, new IConstant [] { a } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { b, b } )
+ } ;
+
+ //
+ // the expected solutions
+ //
+ IBindingSet expected [] = new IBindingSet []
+ {
+ new ArrayBindingSet ( new IVariable<?> [] { y }, new IConstant [] { a } )
+ , new ArrayBindingSet ( new IVariable<?> [] {}, new IConstant [] {} )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, e } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, c } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { a, a } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { b, d } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { b, b } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x }, new IConstant [] { c } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { d, b } )
+ , new ArrayBindingSet ( new IVariable<?> [] { x, y }, new IConstant [] { d, a } )
+ } ;
+
+ BOpStats stats = query.newStats () ;
+
+ IAsynchronousIterator<IBindingSet[]> source = new ThickAsynchronousIterator<IBindingSet[]> ( new IBindingSet [][] { data } ) ;
+
+ IBlockingBuffer<IBindingSet[]> sink = query.newBuffer ( stats ) ;
+
+ BOpContext<IBindingSet> context = new BOpContext<IBindingSet> ( new MockRunningQuery ( null/* fed */
+ , null/* indexManager */
+ )
+ , -1/* partitionId */
+ , stats
+ , source
+ , sink
+ , null/* sink2 */
+ ) ;
+
+ query.eval ( context ).run () ;
+
+ TestQueryEngine.assertSameSolutions ( expected, sink.iterator () ) ;
+
+ assertEquals ( 1, stats.chunksIn.get () ) ;
+ assertEquals ( 10, stats.unitsIn.get () ) ;
+ assertEquals ( 10, stats.unitsOut.get () ) ;
+ assertEquals ( 1, stats.chunksOut.get () ) ;
+ }
+
+ ///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
+ @SuppressWarnings("serial")
+ private class StringComparatorOp extends ComparatorOp
+ {
+ public StringComparatorOp ( ISortOrder<?> sors [] )
+ {
+ super ( new BOp [] {}, NV.asMap ( new NV [] { new NV ( ComparatorOp.Annotations.ORDER, sors ) } ) ) ;
+ _sors = sors ;
+ }
+
+ public int compare ( IBindingSet o1, IBindingSet o2 )
+ {
+ for ( ISortOrder<?> sor : _sors )
+ {
+ int ret = compare ( sor, o1, o2 ) ;
+ if ( 0 != ret )
+ return ret ;
+ }
+ return 0 ;
+ }
+
+ private int compare ( ISortOrder<?> sor, IBindingSet lhs, IBindingSet rhs )
+ {
+ int compare = 0 ;
+
+ IConstant<?> lhsv = lhs.get ( sor.getVariable () ) ;
+ IConstant<?> rhsv = rhs.get ( sor.getVariable () ) ;
+
+ if ( null == lhsv && null == rhsv )
+ return 0 ;
+ else if ( null == lhsv )
+ compare = -1 ;
+ else if ( null == rhsv )
+ compare = 1 ;
+ else
+ compare = lhsv.toString ().compareTo ( rhsv.toString () ) ;
+
+ return compare * ( sor.isAscending () ? 1 : -1 ) ;
+ }
+ private ISortOrder<?> [] _sors = null ;
}
-
-}
+}
\ No newline at end of file
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
