Index: src/uk/ac/gla/terrier/structures/collections/FSOrderedMapFile.java
===================================================================
--- src/uk/ac/gla/terrier/structures/collections/FSOrderedMapFile.java	(revision 2662)
+++ src/uk/ac/gla/terrier/structures/collections/FSOrderedMapFile.java	(working copy)
@@ -1,14 +1,19 @@
 package uk.ac.gla.terrier.structures.collections;
 
+import gnu.trove.TObjectIntHashMap;
+
 import java.io.Closeable;
 import java.io.DataInput;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
+import java.io.File;
 import java.io.Flushable;
 import java.io.IOException;
 import java.util.AbstractCollection;
 import java.util.AbstractSet;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
@@ -17,12 +22,19 @@
 import java.util.Set;
 import java.util.TreeMap;
 
+import junit.framework.TestCase;
+
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.Text;
 import org.apache.hadoop.io.Writable;
 import org.apache.hadoop.io.WritableComparable;
 import org.apache.log4j.Logger;
+import org.junit.Test;
 
 import uk.ac.gla.terrier.structures.IndexUtil;
 import uk.ac.gla.terrier.structures.Skipable;
+import uk.ac.gla.terrier.structures.seralization.FixedSizeIntWritableFactory;
+import uk.ac.gla.terrier.structures.seralization.FixedSizeTextFactory;
 import uk.ac.gla.terrier.structures.seralization.FixedSizeWriteableFactory;
 import uk.ac.gla.terrier.structures.seralization.WriteableFactory;
 import uk.ac.gla.terrier.utility.Files;
@@ -46,6 +58,115 @@
         > 
     implements OrderedMap<K,V>, Closeable
 {
+	
+	
+	public static class FSOrderedMapFileTest extends TestCase
+	{
+		String file = "/tmp/testFSOMapfile" + FSOrderedMapFile.USUAL_EXTENSION;
+		String[] testKeys = new String[]{"00", "0000", "1", "a", "z"};
+		String[] testNotInKeys = new String[]{"0", "000", "zz"};
+		protected TObjectIntHashMap<String> key2id = new TObjectIntHashMap<String>();
+		
+		@Override
+		protected void setUp() throws Exception {
+			super.setUp();
+			
+			MapFileWriter w = FSOrderedMapFile.mapFileWrite(file);
+			FixedSizeWriteableFactory<Text> keyFactory = new FixedSizeTextFactory(20);
+			int offset = 0;
+			for(String key : testKeys)
+			{
+				Text wkey = keyFactory.newInstance();
+				IntWritable wvalue = new IntWritable();
+				wkey.set(key);
+				wvalue.set(offset);
+
+				w.write(wkey, wvalue);
+				key2id.put(key, offset);
+				offset++;
+			}
+			w.close();			
+		}
+		
+		protected void checkKeys(FixedSizeTextFactory keyFactory, Map<Text,IntWritable> mapToCheck) throws Exception
+		{
+			for(String key : testKeys)
+			{
+				Text testKey = keyFactory.newInstance();
+				testKey.set(key);
+				IntWritable rtr = mapToCheck.get(testKey);
+				assertNotNull("Got null response for key " + key, rtr);
+				assertEquals("Response for key " + key + " was wrong", key2id.get(key), rtr.get());
+			}
+			String[] randomOrderedTestKeys = new String[testKeys.length];
+			System.arraycopy(testKeys, 0, randomOrderedTestKeys, 0, testKeys.length);
+			Collections.shuffle(Arrays.asList(randomOrderedTestKeys));
+			for(String key : randomOrderedTestKeys)
+			{
+				Text testKey = keyFactory.newInstance();
+				testKey.set(key);
+				IntWritable rtr = mapToCheck.get(testKey);
+				assertNotNull("Got null response for key " + key, rtr);
+				assertEquals("Response for key " + key + " was wrong", key2id.get(key), rtr.get());
+			}
+	
+			for(String key : testNotInKeys)
+			{
+				Text testKey = keyFactory.newInstance();
+				testKey.set(key);
+				IntWritable rtr = mapToCheck.get(testKey);
+				assertNull("Got non null response for key " + key, rtr);
+			}
+		}
+		
+		protected void readStream(Iterator<Map.Entry<Text, IntWritable>> iterator) throws Exception
+		{
+			TObjectIntHashMap<String> copyKey2Id = key2id.clone();
+			while(iterator.hasNext())
+			{
+				Map.Entry<Text, IntWritable> e = iterator.next();
+				assertNotNull(e);
+				assertNotNull(e.getKey());
+				if (copyKey2Id.containsKey(e.getKey().toString()))
+				{
+					assertEquals(copyKey2Id.get(e.getKey().toString()), e.getValue().get());
+					copyKey2Id.remove(e.getKey().toString());
+				}				
+			}
+			assertTrue(copyKey2Id.size() == 0);
+		}
+		
+		@Test public void testStream() throws Exception
+		{
+			FixedSizeTextFactory keyFactory = new FixedSizeTextFactory(20);
+			FSOrderedMapFile.EntryIterator<Text, IntWritable> inputStream = new FSOrderedMapFile.EntryIterator<Text, IntWritable>(
+					file, keyFactory, new FixedSizeIntWritableFactory());
+			readStream(inputStream);
+			inputStream.close();
+		}
+		
+		@Test public void testOnDisk() throws Exception
+		{
+			FixedSizeTextFactory keyFactory = new FixedSizeTextFactory(20);
+			FSOrderedMapFile<Text, IntWritable> mapfile = new FSOrderedMapFile<Text, IntWritable>(file, false, keyFactory, new FixedSizeIntWritableFactory());
+			checkKeys(keyFactory, mapfile);
+		}
+		
+		@Test public void testInMemory() throws Exception
+		{
+			FixedSizeTextFactory keyFactory = new FixedSizeTextFactory(20);
+			Map<Text, IntWritable> mapfileInMem = new FSOrderedMapFile.MapFileInMemory<Text, IntWritable>(file, keyFactory, new FixedSizeIntWritableFactory());
+			checkKeys(keyFactory, mapfileInMem);
+		}
+		
+		@Override
+		protected void tearDown() throws Exception {
+			super.tearDown();
+			new File(file).delete();
+		}		
+		
+	}
+	
 	public static final String USUAL_EXTENSION = ".fsomapfile";
 	
     /** The logger used for this class */
@@ -591,24 +712,24 @@
 		
 		try{
 		
-			while (low <= high) {
-			    //System.err.println("high="+high + " low="+low);
+			while (low < high) {
+			    System.err.println("high="+high + " low="+low);
 			    i = (low + high) >>> 1;
-                //System.err.println("i="+i);
+                System.err.println("i="+i);
                 dataFile.seek((long)i * entrySize);
                 testKey.readFields(dataFile);
-                //System.err.println("Checking "+testKey.toString() + " cmp="+key.compareTo(testKey));
+                System.err.println("Checking "+testKey.toString() + " cmp="+key.compareTo(testKey));
                 if ((compareEntry = testKey.compareTo(key))< 0)
                 	low = i + 1;
                 else if (compareEntry > 0)
-                	high = i - 1;
+                	high = i /*- 1*/;
                 else 
                 {
                     //read the rest and return the data
                     value.readFields(dataFile);
                     return new MapFileEntry<K,V>(testKey, value, i);
                 }
-                //System.err.println("high="+high + " low="+low);
+                System.err.println("high="+high + " low="+low);
             }
         
             if (high == numberOfEntries)