diff --git a/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java b/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
new file mode 100644
index 0000000..8b1e8a4
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
@@ -0,0 +1,57 @@
+package de.ids_mannheim.korap.query;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.TermContext;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.Spans;
+import org.apache.lucene.util.Bits;
+
+import de.ids_mannheim.korap.query.spans.DistanceSpan;
+
+/** Match two ordered Spans with minimum and maximum distance constraints.
+ * 	In this query, the distance unit is the difference between two 
+ * 	token positions.
+ * 
+ * 	@author margaretha
+ * */
+public class SpanDistanceQuery extends SimpleSpanQuery {
+	
+	private int minDistance, maxDistance; // token positions
+	private boolean collectPayloads;
+	private SpanQuery firstClause, secondClause; 
+	
+	public SpanDistanceQuery(SpanQuery firstClause, SpanQuery secondClause, 
+			int minDistance, int maxDistance, boolean collectPayloads) {
+		super(firstClause, secondClause, "spanDistance");		
+    	this.firstClause=firstClause;
+    	this.secondClause=secondClause;
+    	this.minDistance =minDistance;
+		this.maxDistance = maxDistance;
+		this.collectPayloads = collectPayloads;
+	}
+	
+	@Override
+	public SpanDistanceQuery clone() {
+		SpanDistanceQuery spanDistanceQuery = new SpanDistanceQuery(
+			    (SpanQuery) firstClause.clone(),
+			    (SpanQuery) secondClause.clone(),
+			    this.minDistance,
+			    this.maxDistance,
+			    this.collectPayloads
+		        );
+		spanDistanceQuery.setBoost(getBoost());
+		return spanDistanceQuery;	
+	}
+
+	@Override
+	public Spans getSpans(AtomicReaderContext context, Bits acceptDocs,
+			Map<Term, TermContext> termContexts) throws IOException {		
+		return new DistanceSpan(this, context, acceptDocs, termContexts, 
+				minDistance, maxDistance);
+	}
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/CandidateSpan.java b/src/main/java/de/ids_mannheim/korap/query/spans/CandidateSpan.java
new file mode 100644
index 0000000..dd49894
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/CandidateSpan.java
@@ -0,0 +1,66 @@
+package de.ids_mannheim.korap.query.spans;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import org.apache.lucene.search.spans.Spans;
+
+/** A span kept as a candidate for matching with another Span
+ * 	@author margaretha
+ * */
+public class CandidateSpan {	
+	private int doc,start,end;
+	private long cost;
+	private Collection<byte[]> payloads;
+	
+	public CandidateSpan(Spans span) throws IOException {
+		this.doc = span.doc();
+		this.start = span.start();
+		this.end = span.end();
+		this.cost = span.cost();
+		
+		if (span.isPayloadAvailable()){
+			this.payloads = span.getPayload();
+		}
+		else{ 
+			this.payloads = null;
+		}
+	}
+	
+	public int getDoc() {
+		return doc;
+	}
+	public void setDoc(int doc) {
+		this.doc = doc;
+	}
+	public int getStart() {
+		return start;
+	}
+	public void setStart(int start) {
+		this.start = start;
+	}
+	public int getEnd() {
+		return end;
+	}
+	public void setEnd(int end) {
+		this.end = end;
+	}
+
+	public Collection<byte[]> getPayloads() {
+		return payloads;
+	}
+
+	public void setPayloads(Collection<byte[]> payloads) {
+		this.payloads = payloads;
+	}
+
+	public long getCost() {
+		return cost;
+	}
+
+	public void setCost(long cost) {
+		this.cost = cost;
+	}
+	
+	
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpan.java b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpan.java
new file mode 100644
index 0000000..022f5d4
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpan.java
@@ -0,0 +1,251 @@
+package de.ids_mannheim.korap.query.spans;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.TermContext;
+import org.apache.lucene.search.spans.Spans;
+import org.apache.lucene.util.Bits;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.ids_mannheim.korap.query.SimpleSpanQuery;
+import de.ids_mannheim.korap.query.SpanDistanceQuery;
+
+public class DistanceSpan extends Spans{
+	
+	private boolean isStartEnumeration;
+	private boolean hasMoreSpans;
+	private boolean hasMoreFirstSpans;	
+	private boolean collectPayloads;
+	private int minDistance,maxDistance;
+		
+	protected int doc, start, end;	
+	private List<byte[]> payload;   
+    
+    private SpanDistanceQuery query;
+    protected Spans firstSpans, secondSpans;   
+	private List<CandidateSpan> candidateList;
+	private int candidateListIndex;
+	private int candidateListDocNum;
+	
+    private Logger log = LoggerFactory.getLogger(SimpleSpans.class);
+    
+	public DistanceSpan(SpanDistanceQuery spanDistanceQuery,
+			AtomicReaderContext context, Bits acceptDocs,
+			Map<Term, TermContext> termContexts,
+			int minDistance,
+			int maxDistance)
+			throws IOException {
+		this(spanDistanceQuery, context, acceptDocs, termContexts, 
+			minDistance, maxDistance, true);		
+	}
+	
+	public DistanceSpan(SpanDistanceQuery spanDistanceQuery,
+			AtomicReaderContext context, Bits acceptDocs,
+			Map<Term, TermContext> termContexts,
+			int minDistance,
+			int maxDistance,
+			boolean collectPayloads)
+			throws IOException {
+		
+		this.query = spanDistanceQuery;
+		this.minDistance = minDistance;
+		this.maxDistance = maxDistance;		
+  		this.collectPayloads = collectPayloads; // TODO: always true ?
+  		this.payload = new LinkedList<byte[]>();
+  		this.doc = -1;
+  		this.start = -1;
+  		this.end = -1;
+		  		
+  		// Get the enumeration of the two spans to match
+  		firstSpans = spanDistanceQuery.getFirstClause().
+  			getSpans(context, acceptDocs, termContexts);
+  		secondSpans = spanDistanceQuery.getSecondClause().
+  			getSpans(context, acceptDocs, termContexts);  	  	
+  		 		  		
+  		hasMoreFirstSpans = firstSpans.next();
+  		hasMoreSpans = hasMoreFirstSpans;
+  		
+		candidateList = new ArrayList<>();
+		candidateListIndex = -1;
+		candidateListDocNum = firstSpans.doc();
+		
+		isStartEnumeration=true;
+	}	
+	
+	@Override
+	public boolean next() throws IOException {		
+		isStartEnumeration=false;
+  		payload.clear();
+		return advance();
+	}
+	
+	private boolean advance() throws IOException {
+		while( hasMoreSpans && candidateListIndex < candidateList.size() ){					
+			// Check candidates
+			for (candidateListIndex++;candidateListIndex < candidateList.size();
+					candidateListIndex++){
+				if (findMatch())					
+					return true;					
+			}			
+			// Forward secondspan
+			if (hasMoreSpans = secondSpans.next())			
+				setCandidateList();
+		}
+		return false;
+	}
+	
+ 	private void setCandidateList() throws IOException{
+ 		if (candidateListDocNum == secondSpans.doc()){						
+			copyPossibleCandidates();
+			addNewCandidates();
+			candidateListIndex = -1;
+ 		}
+ 		else {
+ 			candidateList.clear(); 			
+ 			if (hasMoreFirstSpans && ensureSameDoc()){
+ 				candidateListDocNum = firstSpans.doc();
+				addNewCandidates();
+				candidateListIndex = -1;
+			}		
+		} 		
+	}
+	
+	private void copyPossibleCandidates(){
+		List<CandidateSpan> temp = new ArrayList<>();
+		for (CandidateSpan cs : candidateList){
+			if (cs.getEnd()+maxDistance > secondSpans.start())
+				temp.add(cs);
+		}
+		candidateList = temp;
+	}
+	
+	private void addNewCandidates() throws IOException{
+		while ( hasMoreFirstSpans && 
+				firstSpans.doc() == candidateListDocNum &&
+				firstSpans.start() < secondSpans.end()){
+			
+			if (firstSpans.end()+maxDistance > secondSpans.start())
+				candidateList.add(new CandidateSpan(firstSpans));
+			
+			hasMoreFirstSpans = firstSpans.next();
+		}
+	}
+	
+	
+	
+	/** Skip the current first or second span until both the spans are in the same doc.
+	 * @return true iff the first and second spans are in the same doc.
+	 * */
+  	private boolean ensureSameDoc() throws IOException {  		
+  		while (firstSpans.doc() != secondSpans.doc()) {
+  			if (firstSpans.doc() < secondSpans.doc()){
+  				if (!firstSpans.skipTo(secondSpans.doc())){
+  					hasMoreSpans = false;  					
+  					return false;
+  				}				
+  			}		
+  			else {
+  				if (!secondSpans.skipTo(firstSpans.doc())){
+  					hasMoreSpans = false;
+  					return false;
+  				}	
+  			}			
+  		}  		
+  		return true;
+  	}
+
+
+	protected boolean findMatch() throws IOException {
+		CandidateSpan candidateSpan = candidateList.get(candidateListIndex);		
+		if (minDistance == 0 &&
+				// intersection
+				candidateSpan.getStart() < secondSpans.end() && 
+				secondSpans.start() < candidateSpan.getEnd()){
+			
+			this.start = Math.min(candidateSpan.getStart(), secondSpans.start());
+			this.end = Math.max(candidateSpan.getEnd(), secondSpans.end());
+			setDocAndPayload(candidateSpan);
+			return true;			
+		}
+		
+		int actualDistance = secondSpans.start() - candidateSpan.getEnd() +1;
+		if (candidateSpan.getStart() < secondSpans.start() &&
+				minDistance <= actualDistance && 
+				actualDistance <= maxDistance){
+						
+			this.start = candidateSpan.getStart();
+			this.end = secondSpans.end();
+			setDocAndPayload(candidateSpan);
+			return true;
+		}		
+		return false;
+	}
+	
+	private void setDocAndPayload(CandidateSpan candidateSpan) throws IOException{ 
+		this.doc = secondSpans.doc();		
+		if (collectPayloads){			
+  		    if (candidateSpan.getPayloads() != null) {  		    	
+  		    	payload.addAll(candidateSpan.getPayloads());
+  		    	log.trace("first",payload.size());
+  		    }
+  		    if (secondSpans.isPayloadAvailable()) {
+  		    	payload.addAll(secondSpans.getPayload());
+  		    	log.trace("second",payload.size());
+  		    }
+		} 
+	}
+
+	@Override
+	public boolean skipTo(int target) throws IOException {
+		if (hasMoreSpans && (secondSpans.doc() < target)){
+  			if (!secondSpans.skipTo(target)){
+  				candidateList.clear();
+  				return false;
+  			}
+  		} 	
+		
+		setCandidateList();
+		payload.clear();
+		isStartEnumeration=false;
+		return advance();
+	}
+
+	@Override
+	public int doc() {		
+		return this.doc;
+	}
+
+	@Override
+	public int start() {
+		return this.start;
+	}
+
+	@Override
+	public int end() {
+		return this.end;
+	}
+
+	@Override
+	public Collection<byte[]> getPayload() throws IOException {
+		return this.payload;
+	}
+
+	@Override
+	public boolean isPayloadAvailable() throws IOException {		
+		return !this.payload.isEmpty();
+	}
+
+	@Override
+	public long cost() {
+		CandidateSpan candidateSpan = candidateList.get(candidateListIndex);
+		return candidateSpan.getCost() + secondSpans.cost();
+	}
+}
diff --git a/src/test/java/de/ids_mannheim/korap/index/TestDistanceQuery.java b/src/test/java/de/ids_mannheim/korap/index/TestDistanceQuery.java
new file mode 100644
index 0000000..11f5a04
--- /dev/null
+++ b/src/test/java/de/ids_mannheim/korap/index/TestDistanceQuery.java
@@ -0,0 +1,298 @@
+package de.ids_mannheim.korap.index;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import de.ids_mannheim.korap.KorapIndex;
+import de.ids_mannheim.korap.KorapResult;
+import de.ids_mannheim.korap.query.SpanDistanceQuery;
+import de.ids_mannheim.korap.query.SpanElementQuery;
+import de.ids_mannheim.korap.query.SpanSegmentQuery;
+
+@RunWith(JUnit4.class)
+public class TestDistanceQuery {
+    KorapResult kr;
+    KorapIndex ki;   
+ 
+    private FieldDocument createFieldDoc0() {
+    	FieldDocument fd = new FieldDocument();
+        fd.addString("ID", "doc-0");
+        fd.addTV("base",
+            "text",             
+            "[(0-1)s:b|s:c|_1#0-1]" +
+            "[(1-2)s:b|_2#1-2]" +             
+            "[(2-3)s:c|_3#2-3]" +
+            "[(3-4)s:c|_4#3-4]" + 
+            "[(4-5)s:d|_5#4-5]" +             
+            "[(5-6)s:d|_6#5-6]");
+        return fd;
+	}
+    
+    private FieldDocument createFieldDoc1(){
+    	FieldDocument fd = new FieldDocument();
+        fd.addString("ID", "doc-1");
+        fd.addTV("base",
+            "text",             
+            "[(0-1)s:c|_1#0-1]" +
+            "[(1-2)s:e|_2#1-2]" +             
+            "[(2-3)s:c|_3#2-3|<>:y#2-4$<i>4]" +
+            "[(3-4)s:c|_4#3-4|<>:x#3-7$<i>7]" + 
+            "[(4-5)s:d|_5#4-5|<>:y#4-6$<i>6]" +             
+            "[(5-6)s:c|_6#5-6|<>:y#5-8$<i>8]" +
+            "[(6-7)s:d|_7#6-7]" +
+            "[(7-8)s:e|_8#7-8|<>:x#7-9$<i>9]" + 
+            "[(8-9)s:e|_9#8-9|<>:x#8-10$<i>10]" + 
+            "[(9-10)s:d|_10#9-10]");
+        return fd;
+    }
+    
+    private FieldDocument createFieldDoc2() {
+    	FieldDocument fd = new FieldDocument();
+        fd.addString("ID", "doc-2");
+        fd.addTV("base",
+            "text",             
+            "[(0-1)s:b|_1#0-1]" +
+            "[(1-2)s:b|_2#1-2]" +             
+            "[(2-3)s:d|_3#2-3]" +
+            "[(3-4)s:e|_4#3-4]" + 
+            "[(4-5)s:d|_5#4-5]" +             
+            "[(5-6)s:e|_6#5-6]");
+        return fd;
+	}
+    
+    private SpanQuery createQuery(String x, String y, int min, int max){
+    	SpanQuery sq = new SpanDistanceQuery(
+        		new SpanTermQuery(new Term("base",x)),
+        		new SpanTermQuery(new Term("base",y)),
+        		min,
+        		max,
+        		true
+        );
+    	return sq;
+    }
+    
+    private SpanQuery createElementQuery(String x, String y, int min, int max){
+    	SpanQuery sq = new SpanDistanceQuery(
+        		new SpanElementQuery("base",x),
+        		new SpanElementQuery("base",y),
+        		min,
+        		max,
+        		true
+        );
+    	return sq;
+    }
+    
+    /**	- Intersection 
+     * 	- Multiple occurrences in the same doc  
+     *  - hasMoreFirstSpans = false for the current secondspan  
+     * */
+    @Test
+    public void testCase1() throws IOException{
+    	ki = new KorapIndex();
+        ki.addDoc(createFieldDoc0()); 
+        ki.commit();
+        SpanQuery sq;
+        // ---- Distance 0 to 1
+        sq = createQuery("s:b","s:c",0,1);                
+        kr = ki.search(sq, (short) 10);
+        
+        assertEquals(2, kr.totalResults());
+        assertEquals(0, kr.match(0).startPos);
+        assertEquals(1, kr.match(0).endPos);
+        assertEquals(1, kr.match(1).startPos);
+        assertEquals(3, kr.match(1).endPos);
+        
+        // ---- Distance 2 to 2
+        sq = createQuery("s:b","s:c",2,2);                
+        kr = ki.search(sq, (short) 10);
+        
+        assertEquals(2, kr.totalResults());
+        assertEquals(0, kr.match(0).startPos);
+        assertEquals(3, kr.match(0).endPos);
+        assertEquals(1, kr.match(1).startPos);
+        assertEquals(4, kr.match(1).endPos);
+        
+        // ---- Distance 2 to 3
+        sq = createQuery("s:b","s:c",2,3);                
+        kr = ki.search(sq, (short) 10);
+        
+        assertEquals(3, kr.totalResults());
+        
+        ki.close();
+    }
+    
+    /** - Check candidate list: 
+     * 	- CandidateList should not contain firstspans that are too far from 
+     * 	  the current secondspan
+     * 	- Add new candidates  
+     * */
+    @Test
+    public void testCase2() throws IOException{
+    	ki = new KorapIndex();
+	    ki.addDoc(createFieldDoc1()); 
+	    ki.commit();    
+	    
+	    // ---- Distance 1 to 3
+	    // Candidate list for the current secondspan, is empty
+	    SpanQuery sq = createQuery("s:c","s:d",1,3);                
+	    kr = ki.search(sq, (short) 10);
+	        	    
+	    assertEquals(4, kr.getTotalResults());
+	    assertEquals(2, kr.getMatch(0).startPos);
+	    assertEquals(5, kr.getMatch(0).endPos);
+	    assertEquals(3, kr.getMatch(2).startPos);
+	    assertEquals(7, kr.getMatch(2).endPos);
+	    
+	    ki.addDoc(createFieldDoc0());
+	    ki.commit();
+
+	    // ---- Distance 3 to 3
+	    // Candidate list is empty, but there are secondspans in the other doc
+	    sq = createQuery("s:c","s:d",3,3);                
+	    kr = ki.search(sq, (short) 10);
+	    assertEquals(2, kr.getTotalResults());
+	    
+	    ki.close();
+    }
+        
+    /** - Ensure the same document
+     *  - Multiple matches in multiple documents and atomic indices
+     * */
+    @Test
+    public void testCase3() throws IOException{
+    	ki = new KorapIndex();
+    	ki.addDoc(createFieldDoc0());
+        ki.commit();
+        ki.addDoc(createFieldDoc2());
+        ki.addDoc(createFieldDoc1());
+        ki.commit();
+        
+        SpanQuery sq;
+        sq = createQuery("s:c","s:d",3,3);    
+        kr = ki.search(sq, (short) 10);
+        
+        assertEquals(2, kr.totalResults());
+    }
+    
+    /** - Firstspan.next() is in the other doc, but there is
+     *    still a secondspans in the same doc
+     *  - hasMoreFirstSpan and secondspans.next() are true,
+     *    but ensureSameDoc() = false 
+     * */ 
+    @Test
+    public void testCase4() throws IOException{
+    	ki = new KorapIndex();
+    	ki.addDoc(createFieldDoc0());
+        ki.commit();
+        ki.addDoc(createFieldDoc2());
+        ki.addDoc(createFieldDoc1());
+        ki.commit();
+               
+        // ---- Distance 1 to 2
+        SpanQuery sq = createQuery("s:b","s:c",1,2);                
+        kr = ki.search(sq, (short) 10);
+        
+        assertEquals(3, kr.totalResults());
+        assertEquals(0, kr.getMatch(0).startPos);
+	    assertEquals(3, kr.getMatch(0).endPos);
+	    assertEquals(1, kr.getMatch(1).startPos);
+	    assertEquals(3, kr.getMatch(1).endPos);
+	    assertEquals(1, kr.getMatch(2).startPos);
+	    assertEquals(4, kr.getMatch(2).endPos);
+	    ki.close();      
+    }
+    
+    /** ElementQueries */    
+    @Test
+    public void testCase5() throws IOException{    	
+    	ki = new KorapIndex();
+	    ki.addDoc(createFieldDoc1()); 
+	    ki.commit();    
+	    
+	    // Intersection ---- Distance 0:0
+	    SpanQuery sq = createElementQuery("x","y",0,0);                
+	    kr = ki.search(sq, (short) 10);
+    	
+	    assertEquals(4, kr.totalResults());
+	    assertEquals(2, kr.getMatch(0).startPos);
+	    assertEquals(7, kr.getMatch(0).endPos);
+	    assertEquals(3, kr.getMatch(1).startPos);
+	    assertEquals(7, kr.getMatch(1).endPos);
+	    assertEquals(3, kr.getMatch(2).startPos);
+	    assertEquals(8, kr.getMatch(2).endPos);
+    	
+	    // Next to ---- Distance 1:1
+	    sq = createElementQuery("y","x",1,1);                
+	    kr = ki.search(sq, (short) 10);
+	    
+	    assertEquals(1, kr.totalResults());
+	    assertEquals(5, kr.getMatch(0).startPos);
+	    assertEquals(10, kr.getMatch(0).endPos);
+	    
+	    // ---- Distance 1:2
+	    sq = createElementQuery("y","x",1,2);                
+	    kr = ki.search(sq, (short) 10);
+	    
+	    assertEquals(2, kr.totalResults());	    
+	    assertEquals(4, kr.getMatch(0).startPos);
+	    assertEquals(9, kr.getMatch(0).endPos);
+	    assertEquals(5, kr.getMatch(1).startPos);
+	    assertEquals(10, kr.getMatch(1).endPos);
+	    
+	    // The same element type ---- Distance 1:2
+	    sq = createElementQuery("x","x",1,2);
+	    kr = ki.search(sq, (short) 10);
+	    
+	    assertEquals(2, kr.totalResults());
+	    
+//    	System.out.print(kr.getTotalResults()+"\n");
+//		for (int i=0; i< kr.getTotalResults(); i++){
+//			System.out.println(
+//				kr.match(i).startPos + " " +kr.match(i).endPos
+//		    );
+//		}
+    }
+    
+    /** Skip to */    
+    @Test
+    public void testCase6() throws IOException{    	
+    	ki = new KorapIndex();
+    	ki.addDoc(createFieldDoc2());
+	    ki.addDoc(createFieldDoc1());
+	    ki.commit();
+	    	    
+	    SpanQuery firstClause = createQuery("s:d", "s:e", 3, 4);
+	    kr = ki.search(firstClause, (short) 10); 
+	    
+	    assertEquals(3, kr.totalResults());
+	    assertEquals(0, kr.getMatch(0).getLocalDocID());
+	    assertEquals(2, kr.getMatch(0).startPos);
+	    assertEquals(6, kr.getMatch(0).endPos);
+	    assertEquals(1, kr.getMatch(1).getLocalDocID());
+	    assertEquals(4, kr.getMatch(1).startPos);
+	    assertEquals(8, kr.getMatch(1).endPos);
+	    assertEquals(4, kr.getMatch(2).startPos);
+	    assertEquals(9, kr.getMatch(2).endPos);	    
+	    
+		// The secondspans is skipped to doc# of the current firstspans
+		SpanQuery sq = new SpanSegmentQuery(
+	    		createQuery("s:d","s:e",3,4),
+	    		createElementQuery("y","x",1,2)
+		);	    
+	    kr = ki.search(sq, (short) 10);
+	    
+	    assertEquals(1, kr.totalResults());
+	    assertEquals(4, kr.getMatch(0).startPos);
+	    assertEquals(9, kr.getMatch(0).endPos);	    
+    }
+    
+    
+}
diff --git a/src/test/java/de/ids_mannheim/korap/index/TestSegmentIndex.java b/src/test/java/de/ids_mannheim/korap/index/TestSegmentIndex.java
index e6db8aa..2b52d9d 100644
--- a/src/test/java/de/ids_mannheim/korap/index/TestSegmentIndex.java
+++ b/src/test/java/de/ids_mannheim/korap/index/TestSegmentIndex.java
@@ -30,9 +30,9 @@
 	
 	public TestSegmentIndex() throws IOException {
 		ki = new KorapIndex();
+		ki.addDoc(createFieldDoc0());
 		ki.addDoc(createFieldDoc1());
 		ki.addDoc(createFieldDoc2());
-		ki.addDoc(createFieldDoc3());
 		ki.commit();
 		
 		log = LoggerFactory.getLogger(getClass());
@@ -109,10 +109,10 @@
 //		log.trace("Testcase4");
 		
 		ki = new KorapIndex();
-		ki.addDoc(createFieldDoc1());
+		ki.addDoc(createFieldDoc0());
 		ki.commit();
-		ki.addDoc(createFieldDoc2());		
-		ki.addDoc(createFieldDoc3());
+		ki.addDoc(createFieldDoc1());		
+		ki.addDoc(createFieldDoc2());
 		ki.commit();
 		
 		sq = new SpanSegmentQuery(
@@ -183,7 +183,7 @@
 		assertEquals("EndPos (0)", 2, kr.match(1).endPos);
 	}
 	
-	private FieldDocument createFieldDoc1(){
+	private FieldDocument createFieldDoc0(){
 		fd = new FieldDocument();
 		fd.addString("ID", "doc-0");
 		fd.addTV("base",
@@ -197,7 +197,7 @@
 		return fd;
 	}
 	
-	private FieldDocument createFieldDoc2(){
+	private FieldDocument createFieldDoc1(){
 		fd = new FieldDocument();
 		fd.addString("ID", "doc-1");
 		fd.addTV("base",
@@ -210,7 +210,7 @@
 		return fd;
 	} 
 	
-	private FieldDocument createFieldDoc3(){
+	private FieldDocument createFieldDoc2(){
 		fd = new FieldDocument();
 		fd.addString("ID", "doc-2");
 		fd.addTV("base",