X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Ftestcases%2Forg%2Fsimantics%2Fdataboard%2Ftests%2FTestAccessor.java;fp=bundles%2Forg.simantics.databoard%2Ftestcases%2Forg%2Fsimantics%2Fdataboard%2Ftests%2FTestAccessor.java;h=0d0e3f3c1ed7070d9ad84334e3f9b3b26ee1aea2;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestAccessor.java b/bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestAccessor.java
new file mode 100644
index 000000000..0d0e3f3c1
--- /dev/null
+++ b/bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestAccessor.java
@@ -0,0 +1,997 @@
+/*******************************************************************************
+ *  Copyright (c) 2010 Association for Decentralized Information Management in
+ *  Industry THTH ry.
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License v1.0
+ *  which accompanies this distribution, and is available at
+ *  http://www.eclipse.org/legal/epl-v10.html
+ *
+ *  Contributors:
+ *      VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.databoard.tests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import gnu.trove.map.hash.TObjectIntHashMap;
+
+import java.io.File;
+import java.net.InetAddress;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.simantics.databoard.Accessors;
+import org.simantics.databoard.Bindings;
+import org.simantics.databoard.Datatypes;
+import org.simantics.databoard.accessor.Accessor;
+import org.simantics.databoard.accessor.ArrayAccessor;
+import org.simantics.databoard.accessor.BooleanAccessor;
+import org.simantics.databoard.accessor.ByteAccessor;
+import org.simantics.databoard.accessor.DoubleAccessor;
+import org.simantics.databoard.accessor.FloatAccessor;
+import org.simantics.databoard.accessor.IntegerAccessor;
+import org.simantics.databoard.accessor.LongAccessor;
+import org.simantics.databoard.accessor.MapAccessor;
+import org.simantics.databoard.accessor.OptionalAccessor;
+import org.simantics.databoard.accessor.RecordAccessor;
+import org.simantics.databoard.accessor.StringAccessor;
+import org.simantics.databoard.accessor.UnionAccessor;
+import org.simantics.databoard.accessor.VariantAccessor;
+import org.simantics.databoard.accessor.error.AccessorException;
+import org.simantics.databoard.accessor.event.Event;
+import org.simantics.databoard.accessor.event.InvalidatedEvent;
+import org.simantics.databoard.accessor.file.FileVariantAccessor;
+import org.simantics.databoard.accessor.impl.ChangeSet;
+import org.simantics.databoard.accessor.impl.CompositeRecord;
+import org.simantics.databoard.accessor.impl.DirectoryMap;
+import org.simantics.databoard.accessor.impl.EventCollection;
+import org.simantics.databoard.accessor.interestset.InterestSet;
+import org.simantics.databoard.accessor.wire.WireClient;
+import org.simantics.databoard.accessor.wire.WireServer;
+import org.simantics.databoard.adapter.AdaptException;
+import org.simantics.databoard.binding.ArrayBinding;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.binding.BooleanBinding;
+import org.simantics.databoard.binding.ByteBinding;
+import org.simantics.databoard.binding.DoubleBinding;
+import org.simantics.databoard.binding.FloatBinding;
+import org.simantics.databoard.binding.IntegerBinding;
+import org.simantics.databoard.binding.LongBinding;
+import org.simantics.databoard.binding.MapBinding;
+import org.simantics.databoard.binding.OptionalBinding;
+import org.simantics.databoard.binding.RecordBinding;
+import org.simantics.databoard.binding.StringBinding;
+import org.simantics.databoard.binding.UnionBinding;
+import org.simantics.databoard.binding.VariantBinding;
+import org.simantics.databoard.binding.factory.BindingScheme;
+import org.simantics.databoard.binding.factory.MutableBindingFactory;
+import org.simantics.databoard.binding.impl.ObjectArrayBinding;
+import org.simantics.databoard.binding.mutable.MutableVariant;
+import org.simantics.databoard.binding.util.RandomValue;
+import org.simantics.databoard.method.Client;
+import org.simantics.databoard.method.Server;
+import org.simantics.databoard.serialization.Serializer;
+import org.simantics.databoard.type.Datatype;
+import org.simantics.databoard.type.UnionType;
+import org.simantics.databoard.util.binary.BinaryMemory;
+
+/**
+ * o Set Value
+ * o Get Value
+ * o Listening
+ * o apply
+ * o Rollback
+ * 
+ * o Java Object
+ * o Memory Binary
+ * o File Binary
+ * 
+ * TODO Test {@link InvalidatedEvent}
+ *
+ * @author Toni Kalajainen <toni.kalajainen@vtt.fi>
+ */
+public class TestAccessor {
+
+	RandomValue rv;
+	Map<Datatype, Binding> repository;
+	BindingScheme scheme;
+	/////////////////////////////////////
+	
+
+	public @Before void init() {
+		rv = new RandomValue();
+		repository = new HashMap<Datatype, Binding>();
+		scheme = new MutableBindingFactory( repository );
+	}
+
+	public static File createTmpDir()
+	{
+		String tmp = System.getenv("tmp");
+		if (tmp==null) tmp = "c:/temp";
+		Random r = new Random();
+		String randomName = "tmp-"+(r.nextInt(10000)+10000);
+		File tmpDir = new File(tmp+"/"+randomName);
+		Boolean ok = tmpDir.mkdirs();
+		assertTrue( ok );
+		return tmpDir;
+	}	
+
+	public boolean isKeyShortEnough(Binding binding, Object value) throws AdaptException {
+		String key = (String) Bindings.adapt(value, binding, Bindings.STR_VARIANT); 
+		return key.length()<=200;
+	}
+
+	public @Test void testWireAccessor() throws Exception {
+		System.out.println("Wire accessor test");
+		
+		// TODO: Fix this!
+		if (true) return;
+
+		for (int i=0; i<10000; i++) {
+			Bindings.defaultBindingRepository.clear();
+			Bindings.bindingRepository.clear();
+			Bindings.serializerRepository.clear();
+			repository.clear();
+			System.out.println(i+": ");
+			rv = new RandomValue(i); 
+			rv.refereableRecords = false;
+			Datatype type = rv.randomType(0, 3);
+			Binding binding = scheme.getBindingUnchecked(type);
+			Object instance = binding.accept(rv);
+//			System.out.println(binding.printValue(instance, true));
+			Accessor accessor = Accessors.getAccessor(binding, instance);
+			
+			WireServer wireServer = new WireServer(accessor);
+			Server server = new Server(0, wireServer.getMethodInterface());
+			WireClient wireClient = new WireClient();
+			Client client = new Client(InetAddress.getByName("localhost"), server.getPort(), wireClient.getClientMethodInterface());
+			wireClient.setServerMethodInterface(client.getConnection().getRemoteMethodInterface());
+			Accessor remoteAccessor = (Accessor) wireClient.getAccessor(null);
+			testAccessor( remoteAccessor, false );
+			
+			wireClient.close();
+			client.close();
+			server.close();
+		}
+		
+	}
+		
+	public @Test void testBinaryAccessor() throws Exception {
+		System.out.println("Test Binary Memory:");
+		
+		Datatype type = Datatypes.VARIANT;
+		Binding binding = scheme.getBindingUnchecked( type );
+		Serializer s = binding.serializer();
+		TObjectIntHashMap<Object> identities = new TObjectIntHashMap<Object>();
+		
+		for (int i=0; i<10000; i++) {
+			Bindings.defaultBindingRepository.clear();
+			Bindings.bindingRepository.clear();
+			Bindings.serializerRepository.clear();			
+			repository.clear();			
+			rv = new RandomValue(i); 
+			rv.getRandom().nextLong();
+			rv.refereableRecords = false;
+			System.out.println(i+": ");
+			BinaryMemory ram = new BinaryMemory(0);
+			Object instance = binding.accept(rv);
+			
+			binding.assertInstaceIsValid(instance);
+//			System.out.println(instance);
+			
+			identities.clear();
+			int size = s.getSize(instance, identities);
+			
+			ram.setLength(size);			
+			ram.position(0);
+			identities.clear();
+			s.serialize(ram, identities, instance);
+			identities.clear();
+
+			ram.position(0L);
+			Object instance2 = s.deserialize(ram);
+			assertTrue( binding.equals(instance, instance2) );
+			binding.assertInstaceIsValid(instance2);
+			
+			VariantAccessor a = (VariantAccessor) Accessors.getAccessor(ram, type);
+			
+			testAccessor(a);
+			
+		}
+		
+	}
+
+	
+	public @Test void testJavaAccessor() throws Exception {
+		System.out.println("Test Java Objects:");
+		for (int i=0; i<10000; i++) {
+			Bindings.defaultBindingRepository.clear();
+			Bindings.bindingRepository.clear();
+			Bindings.serializerRepository.clear();
+			repository.clear();			
+			System.out.println(i+": ");
+			rv = new RandomValue(i); 
+			rv.refereableRecords = false;
+			Datatype type = rv.randomType(0, 3);
+			Binding binding = scheme.getBindingUnchecked(type);
+			Object instance = binding.accept(rv);
+//			System.out.println(binding.printValue(instance, true));
+			Accessor accessor = Accessors.getAccessor(binding, instance);
+			testAccessor(accessor);
+		}
+	}	
+
+	/**
+	 * This test tests composite record by adding 10 fields, and running the 
+	 * composition as a record accessor
+	 */
+	public @Test void testCompositeRecord() throws Exception {
+		System.out.println("Test composite accessor");
+		for (int i=0; i<100; i++) {
+			CompositeRecord record = new CompositeRecord();
+			for (int j=1; j<=10; j++) {
+				
+				Binding binding = Bindings.MUTABLE_VARIANT;
+				rv = new RandomValue(i*543+j*23); 
+				rv.getRandom().nextLong();
+				rv.refereableRecords = false;	
+				MutableVariant instance = (MutableVariant) binding.accept(rv);
+				String fieldName = "Field"+j;
+				Accessor fa = Accessors.getAccessor(instance.getBinding(), instance.getValue());
+				record.addField(fieldName, fa);
+			}
+			System.out.println(i);
+			
+			testAccessor( record );
+		}
+	}
+	
+	
+	public @Test void testFolderMap() throws Exception {
+		// 1000 tests proves failure
+		for (int i=0; i<100; i++) {
+			Bindings.defaultBindingRepository.clear();
+			Bindings.bindingRepository.clear();
+			Bindings.serializerRepository.clear();
+			repository.clear();
+			
+			System.out.println(i+": ");
+			File dir = createTmpDir();
+			DirectoryMap map = Accessors.openDirectory(dir);
+			Binding keyBinding = Bindings.STR_VARIANT; 
+			try {
+				System.out.println("Test Folder Map: "+dir);			
+				
+				// Create 10 files
+				for (int j=0; j<10; j++) {
+					rv = new RandomValue(i*231231243+j*213); 
+					rv.refereableRecords = false;
+					
+					// Create Key				
+					String key = "";
+					do {
+						key = (String) keyBinding.accept(rv);
+					} while (key.length() > 240);
+					
+					// Create value 
+					Datatype valueType = rv.randomType(0, 2);					
+					Binding valueBinding = scheme.getBindingUnchecked(valueType);
+					Object value = valueBinding.accept(rv);					
+
+					System.out.println(key);
+					MutableVariant vv = new MutableVariant(valueBinding, value);
+					map.put(Bindings.STR_VARIANT, key, Bindings.MUTABLE_VARIANT, vv);
+				}
+				
+				// Test the map
+				testAccessor(map);
+				
+			} finally {
+				// Remove all files in the folder
+				map.clear();
+				map.close();
+				System.out.println( dir.listFiles().length + " files.");
+				dir.delete();
+			}
+			
+		}
+		
+	}	
+	
+	public @Test void testBinaryFile() throws Exception {
+		File tmpFile = File.createTempFile("TestAccessor", ".dat");
+		System.out.println("Test Binary File: "+tmpFile);
+		tmpFile.deleteOnExit();
+		FileVariantAccessor fa = Accessors.createFile(tmpFile);		
+		Datatype type = Datatypes.VARIANT;
+		Binding binding = scheme.getBindingUnchecked( type );
+		
+		for (int i=0; i<10000; i++) {
+			Bindings.bindingRepository.clear();
+			Bindings.serializerRepository.clear();
+			Bindings.defaultBindingRepository.clear();
+			repository.clear();
+			
+			System.out.println(i+": ");
+			rv = new RandomValue(i);			
+			rv.getRandom().nextLong();
+			rv.refereableRecords = false;
+			
+			Object instance = binding.accept(rv);
+			System.out.print(i+": "+ binding.printValueDefinition(instance, true));
+			fa.setValue(binding, instance);
+			testAccessor(fa);
+		}
+		fa.close();
+		
+	}
+		
+	
+	/////////////////////////////////////
+
+    public void testAccessor(Accessor a) throws Exception {
+        testAccessor(a, true);
+    }
+	
+	public void testAccessor(Accessor a, boolean runTypeSpecific) throws Exception {
+		// Init
+		Datatype type = a.type();
+		Binding binding = scheme.getBindingUnchecked(type);
+		InterestSet is = InterestSet.newInterestSet(type, true, true, true);
+		boolean mutable = !binding.isImmutable();
+		
+		// Original value and test value
+		Object origValue = a.getValue(binding);
+		binding.assertInstaceIsValid(origValue);
+		Object testValue = binding.accept(rv);
+
+		// Test Accessor#getValue(binding, instance);
+		Binding mutableBinding = Bindings.getMutableBinding(type);
+		Object mutableInstance = mutableBinding.createDefault();
+		a.getValue(mutableBinding, mutableInstance);
+		assertTrue( Bindings.equals(binding, origValue, mutableBinding, mutableInstance) );
+				
+		boolean same = binding.equals(origValue, testValue);
+		// Create a reference value and an accessor
+		Object refValue = binding.clone(origValue);
+		Accessor ra = Accessors.getAccessor(binding, refValue);
+		
+		if ( mutable ) {
+	
+			// Write test, without listeners
+			ra.setValue(binding, testValue);
+			Object refClone = ra.getValue(binding);
+			assertTrue( binding.equals(testValue, refClone) );
+			ra.setValue(binding, binding.clone(origValue) );
+			refClone = ra.getValue(binding);
+			assertTrue( binding.equals(origValue, refClone) );
+			
+			// Write test, with listeners
+			ChangeSet cs = new ChangeSet();      // Collects Transformation form origValue to testValue
+			a.addListener(cs, is, null, null);
+			a.setValue(binding, testValue);	
+			// There must be events in change set 
+			if (!same) assertFalse(cs.isEmpty());
+					
+			// Verify the accessor now contains the test value
+			Object x = a.getValue(binding);
+			assertTrue( binding.equals(testValue, x ) ); 
+			
+			// Convert reference value to testValue
+			LinkedList<Event> rollback = new LinkedList<Event>();
+			List<Event> events = cs.getAndClearEvents();  // Transformation form origValue to testValue
+			ra.apply(events, rollback);         // Apply transformation from origValue to testValue, and gather rollback, a transformation from testValue to origValue
+			x = ra.getValue(binding);
+			assertTrue( binding.equals(x, testValue) );
+			
+			// Revert reference value to origValue using rollback
+			a.removeListener(cs);
+			a.apply(rollback, null);            // Apply transformation from testValue to origValue
+			x = a.getValue(binding);
+			assertTrue( binding.equals( x, origValue ) );
+		}
+
+		// Ensure the accessor has the correct value
+		Object x = a.getValue(binding);
+		assertTrue( binding.equals( x, origValue) );
+		
+		if (runTypeSpecific) {
+    		// Type specific tests
+    		if (a instanceof ArrayAccessor) testArrayAccessor((ArrayAccessor) a); 
+    		if (a instanceof RecordAccessor) testRecordAccessor((RecordAccessor) a); 
+    		if (a instanceof MapAccessor) testMapAccessor((MapAccessor) a); 
+    		if (a instanceof BooleanAccessor) testBooleanAccessor((BooleanAccessor) a); 
+    		if (a instanceof ByteAccessor) testByteAccessor((ByteAccessor) a); 
+    		if (a instanceof DoubleAccessor) testDoubleAccessor((DoubleAccessor) a); 
+    		if (a instanceof FloatAccessor) testFloatAccessor((FloatAccessor) a); 
+    		if (a instanceof IntegerAccessor) testIntegerAccessor((IntegerAccessor) a); 
+    		if (a instanceof LongAccessor) testLongAccessor((LongAccessor) a); 
+    		if (a instanceof OptionalAccessor) testOptionalAccessor((OptionalAccessor) a); 
+    		if (a instanceof StringAccessor) testStringAccessor((StringAccessor) a); 
+    		if (a instanceof UnionAccessor) testUnionAccessor((UnionAccessor) a); 
+    		if (a instanceof VariantAccessor) testVariantAccessor((VariantAccessor) a);
+	
+    		// Ensure the accessor has the correct value
+    		a.setValue(binding, origValue);			
+    		x = a.getValue(binding);
+    		assertTrue( binding.equals( x, origValue) );
+		}		
+	}
+	
+	public void testMapAccessor(MapAccessor a) throws Exception {
+		Datatype type = a.type();
+		MapBinding binding = (MapBinding) scheme.getBindingUnchecked(type);
+		Binding kb = binding.getKeyBinding();
+		Binding vb = binding.getValueBinding();
+		InterestSet is = InterestSet.newInterestSet(type, true, true, false);
+		boolean mutable = !binding.isImmutable();
+		int len = a.size();
+		
+		// getAll(Binding, Binding, Object[], Object[])
+		Object oks[] = new Object[ len ];
+		Object ovs[] = new Object[ len ];
+		a.getAll(kb, vb, oks, ovs);
+
+		// getAll(Binding, Binding, Map<Object, Object>)
+		TreeMap<Object, Object> om = new TreeMap<Object, Object>(kb);
+		a.getAll(kb, vb, om);
+
+		// getKeys(Binding), getValues(Binding)
+		Object oks2[] = a.getKeys(kb);
+		Object ovs2[] = a.getValues(vb);		
+		
+		// assert the results are the same for the getAll()s and getKeys and getValues 
+		for (int i=0; i<len; i++) {
+			assertTrue( om.containsKey(oks[i]) );
+			assertTrue( om.containsKey(oks2[i]) );
+			Object v = om.get(oks[i]);
+			assertTrue( vb.equals( v, ovs[i] ) );
+			assertTrue( vb.equals( v, ovs2[i] ) );
+			v = om.get(oks2[i]);
+			assertTrue( vb.equals( v, ovs[i] ) );
+			assertTrue( vb.equals( v, ovs2[i] ) );
+		}
+
+		// Test Get entries
+		if (len>2) {
+			// Get all
+			try {
+	            Object keys[] = new Object[ len ];
+	            Object values[] = new Object[ len ];
+    			int c = a.getEntries(kb, a.getFirstKey(kb), true, a.getLastKey(kb), true, 
+    				new ObjectArrayBinding(kb), keys, 
+    				new ObjectArrayBinding(vb), values, -1);
+    
+    			assertEquals(len, c);
+    			for (int i=0; i<len; i++) {				
+    				assertTrue( kb.equals( oks[i], keys[i] ) );
+    				assertTrue( vb.equals( ovs[i], values[i] ) );
+    			}
+    			
+    			// Exclude first and last
+    			keys = new Object[ len-2 ];
+    			values = new Object[ len-2 ];
+    			c = a.getEntries(kb, a.getFirstKey(kb), false, a.getLastKey(kb), false, 
+    					new ObjectArrayBinding(kb), keys, 
+    					new ObjectArrayBinding(vb), values, -1);
+    			assertEquals(len-2, c);
+    			for (int i=1; i<len-1; i++) {				
+    				assertTrue( kb.equals( oks[i], keys[i-1] ) );
+    				assertTrue( vb.equals( ovs[i], values[i-1] ) );
+    			}
+    	
+    			// Get one
+    			c = a.getEntries(kb, a.getFirstKey(kb), true, a.getLastKey(kb), false, 
+    					new ObjectArrayBinding(kb), keys, 
+    					new ObjectArrayBinding(vb), values, 1);
+    			assertEquals(1, c);
+    			assertTrue( kb.equals( oks[0], keys[0] ) );
+    			assertTrue( vb.equals( ovs[0], values[0] ) );
+			}
+			catch (AccessorException e) {
+			    assertEquals( "Not implemented", e.getMessage() );
+			}
+			
+		}
+		
+		// Create test values
+		TreeSet<Object> keys = new TreeSet<Object>(kb);
+		for (int i=0; i<10; i++) {
+			Object key = null;
+			if (kb.type().equals(Datatypes.VARIANT)) {
+				do {
+					key = kb.accept(rv);
+				} while( !kb.type().equals(Datatypes.VARIANT) || !isKeyShortEnough(kb, key) );			
+			} else {
+				key = kb.accept(rv);				
+			}
+			keys.add( key );
+		}
+		int testValueCount = keys.size();
+		Object tks[] = keys.toArray( new Object[testValueCount] );
+		Object tvs[] = new Object[ testValueCount ];
+		for (int i=0; i<testValueCount; i++) tvs[i] = vb.accept(rv);
+
+		if (len>=3) {
+			// getFirstKey(Binding)
+			Object fk = a.getFirstKey(kb);
+			assertTrue( kb.equals(fk, oks[0]) );
+
+			// getLastKey(Binding)
+			Object lk = a.getLastKey(kb);
+			assertTrue( kb.equals(lk, oks[len-1]) );
+			
+			// getLowerKey(Binding, Object)
+			Object k = a.getLowerKey(kb, fk);
+			assertNull(k);			
+			k = a.getLowerKey(kb, lk);
+			assertTrue( kb.equals(k, oks[len-2]) );  
+			
+			// getFloorKey(Binding, Object)
+			k = a.getFloorKey(kb, fk);
+			assertTrue( kb.equals(k, oks[0]) );  
+			k = a.getFloorKey(kb, lk);
+			assertTrue( kb.equals(k, oks[len-1]) );  
+			
+			// getCeilingKey(Binding, Object)
+			k = a.getCeilingKey(kb, lk);
+			assertTrue( kb.equals(k, oks[len-1]) );  
+			k = a.getCeilingKey(kb, fk);
+			assertTrue( kb.equals(k, oks[0]) );  
+			
+			// getHigherKey(Binding, Object)
+			k = a.getHigherKey(kb, lk);
+			assertNull(k);			
+			k = a.getHigherKey(kb, fk);
+			assertTrue( kb.equals(k, oks[1]) );  
+		}
+
+		// clear
+		// putAll(Binding, Binding, Object[], Object[])
+		a.clear();
+		int size = a.size();
+		assertEquals( 0, size );
+		a.putAll(kb, vb, oks, ovs);
+		size = a.size();		
+		assertEquals( len, size );
+		
+		// clear
+		// putAll(Binding, Binding, Map<Object, Object>)
+		a.clear();
+		assertEquals( 0, a.size() );
+		a.putAll(kb, vb, om);
+		assertEquals( len, a.size() );
+		
+		// containsKey
+		// containsValue
+		for (int i=0; i<len; i++) {
+			assertTrue( a.containsKey(kb, oks[i]) );
+			assertTrue( a.containsValue(vb, ovs[i]) );
+		}
+				
+		// Add, Remove
+		if ( mutable ) {
+			// put (insert)
+			int count = len;
+			for (int i=0; i<testValueCount; i++) {
+				if (!a.containsKey(kb, tks[i])) count++;
+				a.put(kb, tks[i], vb, tvs[i]);
+			}
+			assertEquals(count, a.size());
+			for (int i=0; i<testValueCount; i++) {
+				Object o = a.get(kb, tks[i], vb);
+				assertTrue( vb.equals(tvs[i], o) );
+			}
+			// remove(Binding, Object)
+			for (int i=0; i<testValueCount; i++) {
+				a.remove(kb, tks[i]);
+			}
+			for (int i=0; i<len; i++) {
+				a.remove(kb, oks[i]);
+			}			
+			a.putAll(kb, vb, oks, ovs);
+		}
+		
+		// Set
+		int common = Math.min(len, testValueCount);
+		
+		for (int i=0; i<common; i++) {
+			a.put(kb, oks[i], vb, tvs[i]);
+			Object x = a.get(kb, oks[i], vb);
+			assertTrue( vb.equals( tvs[i], x) );			
+		}
+		for (int i=0; i<common; i++) {
+			a.put(kb, oks[i], vb, ovs[i]);
+			Object x = a.get(kb, oks[i], vb);
+			assertTrue( vb.equals( ovs[i], x ) );			
+		}
+		
+		//// Test sub-accessors with recursion
+		for (int i=0; i<len; i++) {
+			Accessor sa = a.getValueAccessor(kb, oks[i]);
+			testAccessor(sa);
+		}			
+	}
+	
+	public void testArrayAccessor(ArrayAccessor a) throws Exception {
+		Datatype type = a.type();
+		ArrayBinding binding = (ArrayBinding) scheme.getBindingUnchecked(type);
+		Binding cb = binding.getComponentBinding();
+		InterestSet is = InterestSet.newInterestSet(type, true, true, false);
+		boolean mutable = !binding.isImmutable();
+
+		int len = a.size();
+		Object ovs[] = new Object[ len ];
+		a.getAll(cb, ovs);
+
+		//// Create test values
+		int testValueCount = rv.getRandom().nextInt(10)+10;
+		Object tvs[] = new Object[ testValueCount ];
+		Object tvs2[] = new Object[ testValueCount ];
+		for (int i=0; i<testValueCount; i++) {
+			tvs[i] = cb.accept(rv);
+			tvs2[i] = cb.accept(rv);				
+		}			
+		
+		// Add, Remove
+		if ( mutable ) {
+			
+			//// Add in values to end
+			a.addAll(cb, tvs);			
+			// Test get 
+			for (int i=0; i<testValueCount; i++) {
+				Object o1 = a.get(i + len, cb);
+				Object o2 = tvs[i];
+				assertTrue( cb.equals(o1, o2) );
+			}
+			
+			// Test get to existing instance
+			{
+				Object o1 = cb.createDefault();
+				for (int i=0; i<testValueCount; i++) {
+					a.get(i + len, cb, o1);
+					Object o2 = tvs[i];
+					assertTrue( cb.equals(o1, o2) );
+				}
+			}
+
+			// Test getAll
+			Object all[] = new Object[ testValueCount + len ];
+			a.getAll(cb, all);
+			for (int i=0; i<testValueCount; i++) {
+				Object o1 = all[i+len];
+				Object o2 = tvs[i];
+				assertTrue( cb.equals(o1, o2) );
+			}			
+			a.remove(len, testValueCount);
+			for (int i=0; i<len; i++) {
+				Object o1 = ovs[i];
+				Object o2 = a.get(i, cb);
+				assertTrue( cb.equals(o1, o2) );
+			}						
+			assertEquals(len, a.size());
+			
+			
+			//// Add in values to the beginning
+			a.addAll(0, cb, tvs);
+			for (int i=0; i<testValueCount; i++) {
+				Object o1 = a.get(i, cb);
+				Object o2 = tvs[i];
+				assertTrue( cb.equals(o1, o2) );
+			}
+			// Test getAll
+			a.getAll(cb, all);
+			for (int i=0; i<testValueCount; i++) {
+				Object o1 = all[i];
+				Object o2 = tvs[i];
+				assertTrue( cb.equals(o1, o2) );
+			}			
+			a.remove(0, testValueCount);
+			assertEquals(len, a.size());
+		}
+		
+		int oldSize = a.size();
+		a.setSize( oldSize + 10);
+		assertEquals( oldSize+10, a.size() );
+		a.setSize( oldSize );
+		assertEquals( oldSize, a.size() );
+
+		//// Test setValue()
+		int common = Math.min(len, testValueCount);
+		for (int i=0; i<common; i++) 
+			a.set(i, cb, tvs[i]);
+		
+		for (int i=0; i<common; i++) assertTrue( cb.equals( tvs[i], a.get(i, cb)) );
+		for (int i=0; i<common; i++) a.set(i, cb, ovs[i]);		
+		for (int i=0; i<common; i++) assertTrue( cb.equals( ovs[i], a.get(i, cb)) );
+		
+		//// Test sub-accessors with recursion
+		for (int i=0; i<len; i++) {
+			Accessor sa = a.getAccessor(i);
+			testAccessor(sa);
+		}		
+		
+	}
+	
+	public void testRecordAccessor(RecordAccessor a) throws Exception {
+		Datatype type = a.type();
+		RecordBinding binding = (RecordBinding) scheme.getBindingUnchecked(type);
+		Binding cbs[] = binding.getComponentBindings();
+		InterestSet is = InterestSet.newInterestSet(type, true, true, false);
+
+		int len = a.count();
+		Object ovs[] = new Object[ len ];
+		for (int i=0; i<len; i++) ovs[i] = a.getFieldValue(i, cbs[i]);
+
+		//// Create test values
+		Object tvs[] = new Object[ len ];
+		Object tvs2[] = new Object[ len ];
+		for (int i=0; i<len; i++) {
+			tvs[i] = cbs[i].accept(rv);
+			tvs2[i] = cbs[i].accept(rv);				
+		}			
+
+		//// Test setValue()
+//		System.gc();
+		for (int i=0; i<len; i++) 
+			a.setFieldValue(i, cbs[i], tvs[i]);
+		for (int i=0; i<len; i++) assertTrue( cbs[i].equals( tvs[i], a.getFieldValue(i, cbs[i])) );
+		for (int i=0; i<len; i++) a.setFieldValue(i, cbs[i], ovs[i]);		
+		for (int i=0; i<len; i++) assertTrue( cbs[i].equals( ovs[i], a.getFieldValue(i, cbs[i])) );
+		
+		//// Test sub-accessors with recursion
+		for (int i=0; i<len; i++) {
+			Accessor sa = a.getFieldAccessor(i);
+			testAccessor(sa);
+		}		
+		
+	}
+	
+	public void testOptionalAccessor(OptionalAccessor a) throws Exception {
+		Datatype type = a.type();
+		OptionalBinding binding = (OptionalBinding) scheme.getBindingUnchecked(type);
+		Binding cb = binding.getComponentBinding();
+		InterestSet is = InterestSet.newInterestSet(type, true, true, true);
+		
+		// Remember original value
+		boolean hadValue = a.hasValue();
+		Object ov = hadValue ? a.getComponentValue(cb) : null;		
+		Object tv = cb.accept(rv);
+
+		a.setComponentValue(cb, tv);
+		assertTrue( cb.equals(a.getComponentValue(cb), tv) );
+		assertEquals( true, a.hasValue());
+		
+		a.setNoValue();
+		assertEquals( false, a.hasValue());
+
+		// Test Invalidated Event
+		{			
+			a.setNoValue();
+			a.setComponentValue(cb, tv);
+			Accessor sa = a.getComponentAccessor();
+			EventCollection ec = new EventCollection();
+			a.addListener(ec, is, null, null);
+			a.setNoValue();		
+			a.removeListener(ec);
+			boolean invalidatedEventOk = false;
+			for (Event e : ec.getAndClearEvents()) {
+				invalidatedEventOk |= (e instanceof InvalidatedEvent) && (e.reference !=null);
+			}
+			sa.getClass();
+			assertTrue( invalidatedEventOk );				
+		}
+		
+		// Restore value
+		if (hadValue) {
+			a.setComponentValue(cb, ov);
+		} else {
+			a.setNoValue();
+		}
+	}
+	
+	public void testUnionAccessor(UnionAccessor a) throws Exception {
+		UnionType type = a.type();
+		UnionBinding binding = (UnionBinding) scheme.getBindingUnchecked(type);
+		Binding cbs[] = binding.getComponentBindings();
+		InterestSet is = InterestSet.newInterestSet(type, true, true, true);
+		int len = a.count();
+
+		// Get original values
+		int ot = a.getTag();
+		Object ov = a.getComponentValue(cbs[ot]);
+		
+		//// Create test values
+		Object tvs[] = new Object[ len ];
+		Object tvs2[] = new Object[ len ];
+		for (int i=0; i<len; i++) {
+			tvs[i] = cbs[i].accept(rv);
+			tvs2[i] = cbs[i].accept(rv);				
+		}			
+
+		//// Test setValue()
+		for (int i=0; i<len; i++) {
+			a.setComponentValue(i, cbs[i], tvs[i]);
+			assertEquals( i, a.getTag() );
+			assertTrue( Bindings.equals(cbs[i], a.getComponentValue(cbs[i]), cbs[i], tvs[i]) );
+		}
+		
+		// Test Invalidated Event
+		if (type.getComponentCount()>1)
+		{
+			int i=0;
+			a.setComponentValue(i, cbs[i], tvs[i]);
+			Accessor sa = a.getComponentAccessor();
+			EventCollection ec = new EventCollection();
+			a.addListener(ec, is, null, null);
+			i = 1;
+			a.setComponentValue(i, cbs[i], tvs[i]);
+			boolean invalidatedEventOk = false;
+			List<Event> events = ec.getAndClearEvents();
+			for (Event e : events) {
+				invalidatedEventOk |= (e instanceof InvalidatedEvent) && (e.reference !=null);
+			}
+			a.removeListener(ec);
+			sa.getClass();
+			assertTrue( invalidatedEventOk );				
+		}
+		
+		a.setComponentValue(ot, cbs[ot], ov);
+		
+		//// Test sub-accessors with recursion
+		Accessor sa = a.getComponentAccessor();
+		testAccessor(sa);
+		
+	}
+	
+	public void testVariantAccessor(VariantAccessor a) throws Exception {
+		Datatype type = a.type();
+		VariantBinding binding = (VariantBinding) scheme.getBindingUnchecked(type);
+		InterestSet is = InterestSet.newInterestSet(type, true, true, true);
+		
+		// Remember the original value 
+		Binding ob = scheme.getBindingUnchecked( type );
+		Object ov = a.getValue(ob);
+		ob.assertInstaceIsValid(ov);
+		boolean mutable = !binding.isImmutable();
+		
+		if (mutable) {
+			// Create test values
+			int testValueCount = 10;
+			Binding tvb[] = new Binding[testValueCount];
+			Object tvs[] = new Object[testValueCount];
+			for (int i=0; i<testValueCount; i++) {
+				tvb[i] = scheme.getBindingUnchecked( rv.randomType(0, 2) );
+				tvs[i] = tvb[i].accept(rv);
+			}
+		
+			// Set & Get
+			for (int i=0; i<testValueCount; i++) {
+				a.setContentValue(tvb[i], tvs[i]);				
+				Object o = a.getContentValue(tvb[i]);
+				assertTrue( tvb[i].equals(o, tvs[i]) );
+			}
+			
+			// Test Invalidated Event
+			{
+				Binding tb = tvb[1];
+				Object tv = tvs[1];
+				Datatype ct = tvb[0].type();
+				a.setContentValue(tvb[0], tvs[0]);					
+				EventCollection ec = new EventCollection();
+				a.addListener(ec, is, null, null);
+				Accessor sa = a.getContentAccessor();
+				a.setContentValue(tvb[1], tvs[1]);					
+				a.removeListener(ec);
+				
+				// Assigned same type
+				if (ct.getClass().equals(tb.type().getClass())) {
+					
+				} else {				
+					boolean invalidatedEventOk = false;
+					List<Event> events = ec.getAndClearEvents();				
+					for (Event e : events) {
+						invalidatedEventOk |= (e instanceof InvalidatedEvent) && (e.reference !=null);
+					}
+					assertTrue( invalidatedEventOk );
+				}
+			}			
+		}
+		
+		//// Test sub-accessors with recursion
+		Accessor sa = a.getContentAccessor();
+		testAccessor(sa);
+		
+		// Restore
+		a.setValue(ob, ov);		
+	}
+	
+	public void testByteAccessor(ByteAccessor a) throws Exception {
+		byte ov = a.getValue();
+		ByteBinding b = Bindings.BYTE;
+		for (int i=0; i<10; i++) {
+			Byte r = (Byte) rv.visit(b);		
+			a.setValue(r);
+			assertTrue( r == a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+	
+	public void testDoubleAccessor(DoubleAccessor a) throws Exception {
+		double ov = a.getValue();
+		DoubleBinding b = Bindings.DOUBLE;
+		for (int i=0; i<10; i++) {
+			Double r = (Double) rv.visit(b);		
+			a.setValue(r);
+			assertTrue( r == a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+	
+	public void testFloatAccessor(FloatAccessor a) throws Exception {
+		float ov = a.getValue();
+		FloatBinding b = Bindings.FLOAT;
+		for (int i=0; i<10; i++) {
+			Float r = (Float) rv.visit(b);		
+			a.setValue(r);
+			assertTrue( r == a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+	
+	public void testIntegerAccessor(IntegerAccessor a) throws Exception {
+		int ov = a.getValue();
+		IntegerBinding b = Bindings.INTEGER;
+		for (int i=0; i<10; i++) {
+			Integer r = (Integer) rv.visit(b);		
+			a.setValue(r);
+			assertTrue( r == a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+	
+	public void testLongAccessor(LongAccessor a) throws Exception {
+		long ov = a.getValue();
+		LongBinding b = Bindings.LONG;
+		for (int i=0; i<10; i++) {
+			Long r = (Long) rv.visit(b);		
+			a.setValue(r);
+			assertTrue( r == a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+		
+	public void testStringAccessor(StringAccessor a) throws Exception {
+		String ov = a.getValue();
+		StringBinding b = Bindings.STRING;
+		for (int i=0; i<10; i++) {
+			String r = (String) rv.visit(b);		
+			a.setValue(r);
+			assertEquals( r, a.getValue() );
+		}
+		a.setValue(ov);			
+	}
+	
+	public void testBooleanAccessor(BooleanAccessor a) throws Exception {
+		Boolean ov = a.getValue();
+		BooleanBinding b = Bindings.BOOLEAN;
+		for (int i=0; i<10; i++) {
+			Boolean r = (Boolean) rv.visit(b);		
+			a.setValue(r);
+			assertEquals( r, a.getValue() );
+		}
+		a.setValue(ov);	
+	}
+		
+	
+}
+