org.eclipse.photran.core.vpg.tests/src/org/eclipse/rephraserengine/internal/core/tests/vpg/RAMDBTests.java - ptp/org.eclipse.photran - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010 University of Illinois at Urbana-Champaign and others.
  * 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:
  *    UIUC - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.rephraserengine.internal.core.tests.vpg;

 import java.io.File;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;

 import junit.framework.TestCase;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.rephraserengine.core.util.Pair;
 import org.eclipse.rephraserengine.core.util.TwoKeyHashMap;
 import org.eclipse.rephraserengine.core.vpg.IVPGNode;
 import org.eclipse.rephraserengine.core.vpg.VPGDependency;
 import org.eclipse.rephraserengine.core.vpg.VPGEdge;
 import org.eclipse.rephraserengine.core.vpg.db.ram.RAMDB;

 /**
  * Class that checks the correctness of NewDB.java
  *
  * @author Esfar Huq
  * @author Rui Wang
  * @author Jeff Overbey - replaced public fields with MyRAMDB
  */
 @SuppressWarnings(value={"unchecked", "rawtypes"})
 public class RAMDBTests extends TestCase
 {
     private static class MyRAMDB<A, T, R extends IVPGNode<T>> extends RAMDB<A, T, R>
     {
         private static File tempFile = null;

         public MyRAMDB() throws IOException
         {
             super(null, createTempFile());
         }

         private static File createTempFile() throws IOException
         {
             if (tempFile == null)
             {
                 tempFile = File.createTempFile("rephraser", "ramdb");
                 tempFile.deleteOnExit();
             }
             return tempFile;
         }

         @Override
         public long getModificationStamp(String filename)
         {
             return 0L;
         }

         public HashMap<String, Long> files() { return files; }
         public HashSet<VPGDependency<A, T, R>> dependencies() { return dependencies; }
         public HashMap<R, Set<VPGEdge<A, T, R>>> outgoingEdges() { return outgoingEdges; }
         //public HashMap<R, Set<VPGEdge<A, T, R>>> incomingEdges() { return incomingEdges; }
         public TwoKeyHashMap<R, Integer, Serializable> annotations() { return annotations; }

         @Override protected Object readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { return in.readObject(); }
     }

     private MyRAMDB db;

     @Override
     protected void setUp() throws Exception
     {
         super.setUp();

         this.db = new MyRAMDB();
     }

     public void testDependencies() throws CoreException
     {
         assertNotNull(db);
         this.db.clearDatabase();
         assertNotNull(db.dependencies());

         VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
         VPGDependency d2 = new VPGDependency("C.txt", "D.txt");
         VPGDependency d3 = new VPGDependency("C.txt", "E.txt");
         VPGDependency d4 = new VPGDependency("C.txt", "F.txt");

         //ENSURE
         db.ensure(d1);
         db.ensure(d2);
         db.ensure(d2);  //check if duplicates are handled
         db.ensure(d3);
         db.ensure(d4);
         assertEquals(4, db.dependencies().size());

         //DELETE
         db.delete(d1);
         db.delete(d1);
         assertEquals(3, db.dependencies().size());
         assertEquals(true, db.dependencies().contains(d2));

         //GET OUTGOING DEPENDENCIES FROM
         Iterable<String> result1 = db.getOutgoingDependenciesFrom("C.txt");
         assertEquals("[D.txt, E.txt, F.txt]", result1.toString());

         //GET INCOMING DEPENDENCIES TO
         Iterable<String> result2 = db.getIncomingDependenciesTo("E.txt");
         assertEquals("[C.txt]", result2.toString());
     }

     public void testEdges() throws CoreException
     {
         assertNotNull(db);
         this.db.clearDatabase();
         assertNotNull(db.outgoingEdges());

         VPGEdge e1 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "D.txt", 0, 0), Integer.MIN_VALUE);
         VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
         VPGEdge e3 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "A.txt", 0, 0), Integer.MIN_VALUE);

         //ENSURE
         db.ensure(e1);
         db.ensure(e2);
         db.ensure(e3);
         db.ensure(e1);
         assertEquals(2, db.outgoingEdges().keySet().size());

         //DELETE
         db.delete(e3);
         db.delete(e3);
         //System.out.println(db.outgoingEdges());
         assertEquals(2, db.outgoingEdges().keySet().size());

         //GET ALL EDGES FOR
         Iterable<VPGEdge> result1 = db.getAllEdgesFor("B.txt");
         List<VPGEdge> r1 = new ArrayList<VPGEdge>();
         r1.add(e2);

         assertEquals(result1.toString(),r1.toString());
     }

     public void testAnnotations() throws CoreException
     {
         assertNotNull(db);
         this.db.clearDatabase();
         assertNotNull(db.annotations());

         //SET ANNOTATION
         int count = 0;

         TestTokenRef r1 = new TestTokenRef(db, "A.txt", 0, 0);
         TestTokenRef r2 = new TestTokenRef(db, "B.txt", 0, 0);
         TestTokenRef r3 = new TestTokenRef(db, "C.txt", 0, 0);

         byte[] b1 = new byte[] {1, 2, 3};
         byte[] b2 = new byte[] {1, 2, 3};
         byte[] b3 = new byte[] {1, 2, 3};

         db.setAnnotation(r1, 0, b1);
         db.setAnnotation(r2, 1, b2);
         db.setAnnotation(r3, 2, b3);
         db.setAnnotation(r1, 0, b1);

         for(TestTokenRef r : (Set<TestTokenRef>)db.annotations().keySet())
         {
             count += db.annotations().getAllEntriesFor(r).keySet().size();
         }

         assertEquals(3, count);

         //DELETE ANNOTATION
         count = 0;
         db.deleteAnnotation(r2, 1);
         db.deleteAnnotation(r3, 2);
         db.deleteAnnotation(r1, -1);

         for(TestTokenRef r : (Set<TestTokenRef>)db.annotations().keySet())
         {
             count += db.annotations().getAllEntriesFor(r).keySet().size();
         }

         assertEquals(1, count);

         //GET ANNOTATION
         assertEquals(b1, db.getAnnotation(r1, 0));
         assertEquals(null, db.getAnnotation(r3, 2));

         //GET ALL ANNOTATIONS FOR
         Iterable<Pair<TestTokenRef, Integer>> a = db.getAllAnnotationsFor("A.txt");
         assertEquals(a.iterator().next(), new Pair<TestTokenRef, Integer>(r1, 0));
     }

     public void testFiles()
     {
         assertNotNull(db);
         this.db.clearDatabase();
         assertNotNull(db.files());

         //MODIFICATION STAMP
         db.updateModificationStamp("A.txt");
         assertEquals(0L, db.getModificationStamp("A.txt"));

         //DELETE ALL ENTRIES FOR
         VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
         VPGDependency d2 = new VPGDependency("C.txt", "D.txt");
         VPGDependency d3 = new VPGDependency("C.txt", "E.txt");
         VPGDependency d4 = new VPGDependency("C.txt", "F.txt");

         db.ensure(d1);
         db.ensure(d2);
         db.ensure(d3);
         db.ensure(d4);

         VPGEdge e1 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "D.txt", 0, 0), Integer.MIN_VALUE);
         VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
         VPGEdge e3 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "A.txt", 0, 0), Integer.MIN_VALUE);

         db.ensure(e1);
         db.ensure(e2);
         db.ensure(e3);

         TestTokenRef r1 = new TestTokenRef(db, "A.txt", 0, 0);
         TestTokenRef r2 = new TestTokenRef(db, "B.txt", 0, 0);
         TestTokenRef r3 = new TestTokenRef(db, "C.txt", 0, 0);

         byte[] b1 = new byte[] {1, 2, 3};
         byte[] b2 = new byte[] {1, 2, 3};
         byte[] b3 = new byte[] {1, 2, 3};

         db.setAnnotation(r1, 0, b1);
         db.setAnnotation(r2, 1, b2);
         db.setAnnotation(r3, 2, b3);

         db.deleteAllEntriesFor("A.txt");
         assertEquals(3, db.dependencies().size());
         assertEquals(1, db.outgoingEdges().keySet().size());
         assertEquals(2, db.annotations().keySet().size());

         //LIST ALL FILENAMES
         TreeSet<String> filenames = new TreeSet<String>(db.listAllFilenames());
         assertEquals("[A.txt, B.txt, C.txt, D.txt, E.txt, F.txt]", filenames.toString());

         //LIST ALL FILENAMES WITH DEPENDENTS
         filenames = new TreeSet<String>(db.listAllFilenamesWithDependents());
         assertEquals("[D.txt, E.txt, F.txt]", filenames.toString());

         //LIST ALL DEPENDENT FILENAMES
         filenames = new TreeSet<String>(db.listAllDependentFilenames());
         assertEquals("[C.txt]", filenames.toString());
     }

     public void testFlush() throws Exception
     {
         assertNotNull(db);
         this.db.clearDatabase();
         assertNotNull(db.files());
         assertNotNull(db.dependencies());
         assertNotNull(db.outgoingEdges());
         assertNotNull(db.annotations());

         VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
         VPGDependency d2 = new VPGDependency("C.txt", "D.txt");

         db.ensure(d1);
         db.ensure(d2);

         VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
         db.ensure(e2);

         db.flush();
         this.setUp();

         assertEquals(2, db.dependencies().size());
         assertEquals(1, db.outgoingEdges().keySet().size());
         assertEquals(4, db.files().keySet().size());
     }
 }
	/*******************************************************************************
	* Copyright (c) 2010 University of Illinois at Urbana-Champaign and others.
	* 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:
	* UIUC - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.rephraserengine.internal.core.tests.vpg;

	import java.io.File;
	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.Serializable;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.TreeSet;

	import junit.framework.TestCase;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.rephraserengine.core.util.Pair;
	import org.eclipse.rephraserengine.core.util.TwoKeyHashMap;
	import org.eclipse.rephraserengine.core.vpg.IVPGNode;
	import org.eclipse.rephraserengine.core.vpg.VPGDependency;
	import org.eclipse.rephraserengine.core.vpg.VPGEdge;
	import org.eclipse.rephraserengine.core.vpg.db.ram.RAMDB;

	/**
	* Class that checks the correctness of NewDB.java
	*
	* @author Esfar Huq
	* @author Rui Wang
	* @author Jeff Overbey - replaced public fields with MyRAMDB
	*/
	@SuppressWarnings(value={"unchecked", "rawtypes"})
	public class RAMDBTests extends TestCase
	{
	private static class MyRAMDB<A, T, R extends IVPGNode<T>> extends RAMDB<A, T, R>
	{
	private static File tempFile = null;

	public MyRAMDB() throws IOException
	{
	super(null, createTempFile());
	}

	private static File createTempFile() throws IOException
	{
	if (tempFile == null)
	{
	tempFile = File.createTempFile("rephraser", "ramdb");
	tempFile.deleteOnExit();
	}
	return tempFile;
	}

	@Override
	public long getModificationStamp(String filename)
	{
	return 0L;
	}

	public HashMap<String, Long> files() { return files; }
	public HashSet<VPGDependency<A, T, R>> dependencies() { return dependencies; }
	public HashMap<R, Set<VPGEdge<A, T, R>>> outgoingEdges() { return outgoingEdges; }
	//public HashMap<R, Set<VPGEdge<A, T, R>>> incomingEdges() { return incomingEdges; }
	public TwoKeyHashMap<R, Integer, Serializable> annotations() { return annotations; }

	@Override protected Object readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { return in.readObject(); }
	}

	private MyRAMDB db;

	@Override
	protected void setUp() throws Exception
	{
	super.setUp();

	this.db = new MyRAMDB();
	}

	public void testDependencies() throws CoreException
	{
	assertNotNull(db);
	this.db.clearDatabase();
	assertNotNull(db.dependencies());

	VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
	VPGDependency d2 = new VPGDependency("C.txt", "D.txt");
	VPGDependency d3 = new VPGDependency("C.txt", "E.txt");
	VPGDependency d4 = new VPGDependency("C.txt", "F.txt");

	//ENSURE
	db.ensure(d1);
	db.ensure(d2);
	db.ensure(d2); //check if duplicates are handled
	db.ensure(d3);
	db.ensure(d4);
	assertEquals(4, db.dependencies().size());

	//DELETE
	db.delete(d1);
	db.delete(d1);
	assertEquals(3, db.dependencies().size());
	assertEquals(true, db.dependencies().contains(d2));

	//GET OUTGOING DEPENDENCIES FROM
	Iterable<String> result1 = db.getOutgoingDependenciesFrom("C.txt");
	assertEquals("[D.txt, E.txt, F.txt]", result1.toString());

	//GET INCOMING DEPENDENCIES TO
	Iterable<String> result2 = db.getIncomingDependenciesTo("E.txt");
	assertEquals("[C.txt]", result2.toString());
	}

	public void testEdges() throws CoreException
	{
	assertNotNull(db);
	this.db.clearDatabase();
	assertNotNull(db.outgoingEdges());

	VPGEdge e1 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "D.txt", 0, 0), Integer.MIN_VALUE);
	VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
	VPGEdge e3 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "A.txt", 0, 0), Integer.MIN_VALUE);

	//ENSURE
	db.ensure(e1);
	db.ensure(e2);
	db.ensure(e3);
	db.ensure(e1);
	assertEquals(2, db.outgoingEdges().keySet().size());

	//DELETE
	db.delete(e3);
	db.delete(e3);
	//System.out.println(db.outgoingEdges());
	assertEquals(2, db.outgoingEdges().keySet().size());

	//GET ALL EDGES FOR
	Iterable<VPGEdge> result1 = db.getAllEdgesFor("B.txt");
	List<VPGEdge> r1 = new ArrayList<VPGEdge>();
	r1.add(e2);

	assertEquals(result1.toString(),r1.toString());
	}

	public void testAnnotations() throws CoreException
	{
	assertNotNull(db);
	this.db.clearDatabase();
	assertNotNull(db.annotations());

	//SET ANNOTATION
	int count = 0;

	TestTokenRef r1 = new TestTokenRef(db, "A.txt", 0, 0);
	TestTokenRef r2 = new TestTokenRef(db, "B.txt", 0, 0);
	TestTokenRef r3 = new TestTokenRef(db, "C.txt", 0, 0);

	byte[] b1 = new byte[] {1, 2, 3};
	byte[] b2 = new byte[] {1, 2, 3};
	byte[] b3 = new byte[] {1, 2, 3};

	db.setAnnotation(r1, 0, b1);
	db.setAnnotation(r2, 1, b2);
	db.setAnnotation(r3, 2, b3);
	db.setAnnotation(r1, 0, b1);

	for(TestTokenRef r : (Set<TestTokenRef>)db.annotations().keySet())
	{
	count += db.annotations().getAllEntriesFor(r).keySet().size();
	}

	assertEquals(3, count);

	//DELETE ANNOTATION
	count = 0;
	db.deleteAnnotation(r2, 1);
	db.deleteAnnotation(r3, 2);
	db.deleteAnnotation(r1, -1);

	for(TestTokenRef r : (Set<TestTokenRef>)db.annotations().keySet())
	{
	count += db.annotations().getAllEntriesFor(r).keySet().size();
	}

	assertEquals(1, count);

	//GET ANNOTATION
	assertEquals(b1, db.getAnnotation(r1, 0));
	assertEquals(null, db.getAnnotation(r3, 2));

	//GET ALL ANNOTATIONS FOR
	Iterable<Pair<TestTokenRef, Integer>> a = db.getAllAnnotationsFor("A.txt");
	assertEquals(a.iterator().next(), new Pair<TestTokenRef, Integer>(r1, 0));
	}

	public void testFiles()
	{
	assertNotNull(db);
	this.db.clearDatabase();
	assertNotNull(db.files());

	//MODIFICATION STAMP
	db.updateModificationStamp("A.txt");
	assertEquals(0L, db.getModificationStamp("A.txt"));

	//DELETE ALL ENTRIES FOR
	VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
	VPGDependency d2 = new VPGDependency("C.txt", "D.txt");
	VPGDependency d3 = new VPGDependency("C.txt", "E.txt");
	VPGDependency d4 = new VPGDependency("C.txt", "F.txt");

	db.ensure(d1);
	db.ensure(d2);
	db.ensure(d3);
	db.ensure(d4);

	VPGEdge e1 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "D.txt", 0, 0), Integer.MIN_VALUE);
	VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
	VPGEdge e3 = new VPGEdge(new TestTokenRef(db, "C.txt", 0, 0), new TestTokenRef(db, "A.txt", 0, 0), Integer.MIN_VALUE);

	db.ensure(e1);
	db.ensure(e2);
	db.ensure(e3);

	TestTokenRef r1 = new TestTokenRef(db, "A.txt", 0, 0);
	TestTokenRef r2 = new TestTokenRef(db, "B.txt", 0, 0);
	TestTokenRef r3 = new TestTokenRef(db, "C.txt", 0, 0);

	byte[] b1 = new byte[] {1, 2, 3};
	byte[] b2 = new byte[] {1, 2, 3};
	byte[] b3 = new byte[] {1, 2, 3};

	db.setAnnotation(r1, 0, b1);
	db.setAnnotation(r2, 1, b2);
	db.setAnnotation(r3, 2, b3);

	db.deleteAllEntriesFor("A.txt");
	assertEquals(3, db.dependencies().size());
	assertEquals(1, db.outgoingEdges().keySet().size());
	assertEquals(2, db.annotations().keySet().size());

	//LIST ALL FILENAMES
	TreeSet<String> filenames = new TreeSet<String>(db.listAllFilenames());
	assertEquals("[A.txt, B.txt, C.txt, D.txt, E.txt, F.txt]", filenames.toString());

	//LIST ALL FILENAMES WITH DEPENDENTS
	filenames = new TreeSet<String>(db.listAllFilenamesWithDependents());
	assertEquals("[D.txt, E.txt, F.txt]", filenames.toString());

	//LIST ALL DEPENDENT FILENAMES
	filenames = new TreeSet<String>(db.listAllDependentFilenames());
	assertEquals("[C.txt]", filenames.toString());
	}

	public void testFlush() throws Exception
	{
	assertNotNull(db);
	this.db.clearDatabase();
	assertNotNull(db.files());
	assertNotNull(db.dependencies());
	assertNotNull(db.outgoingEdges());
	assertNotNull(db.annotations());

	VPGDependency d1 = new VPGDependency("A.txt", "B.txt");
	VPGDependency d2 = new VPGDependency("C.txt", "D.txt");

	db.ensure(d1);
	db.ensure(d2);

	VPGEdge e2 = new VPGEdge(new TestTokenRef(db, "A.txt", 0, 0), new TestTokenRef(db, "B.txt", 0, 0), Integer.MIN_VALUE);
	db.ensure(e2);

	db.flush();
	this.setUp();

	assertEquals(2, db.dependencies().size());
	assertEquals(1, db.outgoingEdges().keySet().size());
	assertEquals(4, db.files().keySet().size());
	}
	}