src/test/java/com/googlesource/gerrit/plugins/events/fsstore/FsStoreTest.java - plugins/events - Git at Google

 // Copyright (C) 2017 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.googlesource.gerrit.plugins.events.fsstore;

 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 import junit.framework.TestCase;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;

 public class FsStoreTest extends TestCase {
   public static String dir = "events-FsStore";
   public static Path base;
   public static List<OneThread> threads = new LinkedList<>();

   public Path myBase;
   public FsStore store;
   public String id = UUID.randomUUID().toString();
   public String submitMarker = "";
   public long count = 1000;

   public Map<String, Long> reported = new HashMap<String, Long>();

   @Override
   @Before
   public void setUp() throws Exception {
     myBase = base;
     if (myBase == null) {
       myBase = Files.createTempDirectory(dir);
     }
     store = new FsStore(myBase);
   }

   @After
   public void tearDown() throws Exception {
     Fs.tryRecursiveDelete(myBase);
   }

   @Test
   public void testUUIDInit() throws IOException {
     UUID uuid = store.getUuid();
     FsStore store2 = new FsStore(myBase);
     assertEquals(uuid, store2.getUuid());
   }

   @Test
   public void testHeadInit() throws IOException {
     assertEquals(0, store.getHead());
     FsStore store2 = new FsStore(myBase);
     assertEquals(0, store2.getHead());
   }

   @Test
   public void testTailInit() throws IOException {
     assertEquals(0, store.getTail());
     FsStore store2 = new FsStore(myBase);
     assertEquals(0, store2.getTail());
   }

   @Test
   public void testGetInit() throws IOException {
     assertEquals(null, store.get(1));
   }

   @Test
   public void testAdd() throws IOException {
     add();
   }

   public void add() throws IOException {
     long next = store.getHead() + 1;
     assertEquals(0, get(next));

     add(next);
     assertEquals(next, get(next));
     assertEquals(next, store.getHead());
     assertEquals(1, store.getTail());

     FsStore store2 = new FsStore(myBase);
     assertEquals(next, store2.getHead());
     assertEquals(1, store2.getTail());
   }

   private void add(long l) throws IOException {
     store.add("" + l);
   }

   private long get(long i) throws IOException {
     String g = store.get(i);
     return g == null ? 0 : Long.parseLong(g);
   }

   @Test
   public void testAddAgain() throws IOException {
     add();
     add();
     add();
   }

   @Test
   public void testTrim() throws IOException {
     add();
     add();
     add();

     assertEquals(1, store.getTail());
     store.trim(1);
     assertEquals(2, store.getTail());
     assertEquals(0, get(1)); // just deleted
     assertEquals(2, get(2)); // beyond deleted

     store.trim(2);
     assertEquals(3, store.getTail());
     assertEquals(0, get(2)); // just deleted
     assertEquals(3, get(3)); // beyond deleted

     store.trim(3);
     assertEquals(3, store.getTail());
     assertEquals(3, get(3)); // cannot delete head
   }

   @Test
   public void testCount() throws Exception {
     for (long i = 0; i < count; i++) {
       add();
     }
   }

   public void count() throws Exception {
     for (long i = 1; i <= count; i++) {
       store.add(id + " " + i);
       System.out.print(submitMarker);
     }
   }

   public boolean verify(long head) throws Exception {
     Set<Long> found = new HashSet<Long>();
     long stop = store.getHead();
     long mine = 1;

     for (long i = head + 1; i <= stop; i++) {
       String event = store.get(i);
       if (event != null) {
         String split[] = event.split(" ");
         if (split != null && id.equals(split[0])) {
           long n = Long.parseLong(split[1]);
           if (!found.add(n)) {
             report("duplicate", n, i);
           }
           if (mine != n) {
             report("ouf of order", n, i);
           }
           mine++;
         }
       } else {
         report("gap", mine, i);
       }
     }
     for (long i = 1; i <= count; i++) {
       if (!found.contains(i)) {
         report("missing", i, -1);
       }
     }

     boolean error = false;
     error |= reportTotal("duplicate");
     error |= reportTotal("out of order");
     error |= reportTotal("missing");
     error |= reportTotal("gap");
     return error;
   }

   private void report(String type, long n, long i) {
     Long cnt = reported.get(type);
     if (cnt == null) {
       System.out.println("First " + type + ": " + n + " pos(" + i + ")");
       cnt = (long) 0;
     }
     reported.put(type, ++cnt);
   }

   private boolean reportTotal(String type) {
     Long cnt = reported.get(type);
     if (cnt != null) {
       System.out.println("Total " + type + "s: " + cnt);
       return true;
     }
     return false;
   }

   public static class OneThread implements Runnable {
     public FsStoreTest test = new FsStoreTest();
     public Boolean result;

     @Override
     public void run() {
       try {
         test.setUp();
         long head = test.store.getHead();
         test.count();
         result = !test.verify(head);
       } catch (Exception e) {
       }
       if (threads.size() > 1) {
         if (result != null && result) {
           System.out.println("\nPASS " + test.id);
         } else {
           result = false;
           System.out.println("\nFAIL " + test.id);
         }
       }
     }
   }

   /**
    * First, make the junit jar easily available
    *
    * <p>ln -s ~/.m2/repository/junit/junit/4.8.1/junit-4.8.1.jar target
    *
    * <p>To run type:
    *
    * <p>java -cp target/classes:target/test-classes:target/junit-4.8.1.jar \
    * com.googlesource.gerrit.plugins.events.fsstore.FsStoreTest [--id store-id] [dir [count]]
    *
    * <p>Note: if you do not specify <dir>, it will create a directory under /tmp
    *
    * <p>Local(spinning) 1 worker 1M 28m2s ~17ms/event find events|wc -l .97 rm -rf 30s
    */
   public static void main(String[] argv) throws Exception {
     List<String> args = new LinkedList<>();
     for (String arg : argv) {
       args.add(arg);
     }

     setThreadCount(1);
     int thread = 0;
     setSubmitMarker(".");
     for (Iterator<String> it = args.iterator(); it.hasNext(); ) {
       String arg = it.next();
       if (it.hasNext()) {
         if ("--id".equals(arg)) {
           it.remove();
           setId(thread++, it.next());
           it.remove();
         } else if ("-j".equals(arg) || "--threads".equals(arg)) {
           it.remove();
           setThreadCount(new Integer(it.next()));
           it.remove();
         }
       }
     }

     if (args.size() > 0) {
       base = Paths.get(args.remove(0));
     }

     if (args.size() > 0) {
       setCount(Long.parseLong(args.remove(0)));
     }

     runThreads();

     if (getResult()) {
       System.out.println("\nPASS");
     } else {
       System.out.println("\nFAIL");
     }
   }

   private static void runThreads()
       throws IllegalArgumentException, InterruptedException, SecurityException {
     List<Thread> running = new LinkedList<>();

     for (OneThread t : threads) {
       Thread thread = new Thread(t);
       thread.start();
       running.add(thread);
     }

     for (Thread thread : running) {
       thread.join();
     }
   }

   private static boolean getResult() {
     for (OneThread t : threads) {
       if (t.result == null || !t.result) {
         return false;
       }
     }
     return true;
   }

   private static void setCount(long count) {
     for (OneThread t : threads) {
       t.test.count = count;
     }
   }

   private static void setSubmitMarker(String marker) {
     for (OneThread t : threads) {
       t.test.submitMarker = marker;
     }
   }

   private static void setId(int n, String id) {
     OneThread t = threads.get(n);
     t.test.id = id;
     t.test.submitMarker += id + ".";
   }

   private static void setThreadCount(int n) {
     /* Use a common FsStore for all threads so that synchronized will work across them. */
     FsStore commonStore = threads.get(0).test.store;
     while (threads.size() < n) {
       OneThread t = new OneThread();
       t.test.store = commonStore;
       threads.add(t);
     }
   }
 }
	// Copyright (C) 2017 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.googlesource.gerrit.plugins.events.fsstore;

	import java.io.IOException;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.UUID;
	import junit.framework.TestCase;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;

	public class FsStoreTest extends TestCase {
	public static String dir = "events-FsStore";
	public static Path base;
	public static List<OneThread> threads = new LinkedList<>();

	public Path myBase;
	public FsStore store;
	public String id = UUID.randomUUID().toString();
	public String submitMarker = "";
	public long count = 1000;

	public Map<String, Long> reported = new HashMap<String, Long>();

	@Override
	@Before
	public void setUp() throws Exception {
	myBase = base;
	if (myBase == null) {
	myBase = Files.createTempDirectory(dir);
	}
	store = new FsStore(myBase);
	}

	@After
	public void tearDown() throws Exception {
	Fs.tryRecursiveDelete(myBase);
	}

	@Test
	public void testUUIDInit() throws IOException {
	UUID uuid = store.getUuid();
	FsStore store2 = new FsStore(myBase);
	assertEquals(uuid, store2.getUuid());
	}

	@Test
	public void testHeadInit() throws IOException {
	assertEquals(0, store.getHead());
	FsStore store2 = new FsStore(myBase);
	assertEquals(0, store2.getHead());
	}

	@Test
	public void testTailInit() throws IOException {
	assertEquals(0, store.getTail());
	FsStore store2 = new FsStore(myBase);
	assertEquals(0, store2.getTail());
	}

	@Test
	public void testGetInit() throws IOException {
	assertEquals(null, store.get(1));
	}

	@Test
	public void testAdd() throws IOException {
	add();
	}

	public void add() throws IOException {
	long next = store.getHead() + 1;
	assertEquals(0, get(next));

	add(next);
	assertEquals(next, get(next));
	assertEquals(next, store.getHead());
	assertEquals(1, store.getTail());

	FsStore store2 = new FsStore(myBase);
	assertEquals(next, store2.getHead());
	assertEquals(1, store2.getTail());
	}

	private void add(long l) throws IOException {
	store.add("" + l);
	}

	private long get(long i) throws IOException {
	String g = store.get(i);
	return g == null ? 0 : Long.parseLong(g);
	}

	@Test
	public void testAddAgain() throws IOException {
	add();
	add();
	add();
	}

	@Test
	public void testTrim() throws IOException {
	add();
	add();
	add();

	assertEquals(1, store.getTail());
	store.trim(1);
	assertEquals(2, store.getTail());
	assertEquals(0, get(1)); // just deleted
	assertEquals(2, get(2)); // beyond deleted

	store.trim(2);
	assertEquals(3, store.getTail());
	assertEquals(0, get(2)); // just deleted
	assertEquals(3, get(3)); // beyond deleted

	store.trim(3);
	assertEquals(3, store.getTail());
	assertEquals(3, get(3)); // cannot delete head
	}

	@Test
	public void testCount() throws Exception {
	for (long i = 0; i < count; i++) {
	add();
	}
	}

	public void count() throws Exception {
	for (long i = 1; i <= count; i++) {
	store.add(id + " " + i);
	System.out.print(submitMarker);
	}
	}

	public boolean verify(long head) throws Exception {
	Set<Long> found = new HashSet<Long>();
	long stop = store.getHead();
	long mine = 1;

	for (long i = head + 1; i <= stop; i++) {
	String event = store.get(i);
	if (event != null) {
	String split[] = event.split(" ");
	if (split != null && id.equals(split[0])) {
	long n = Long.parseLong(split[1]);
	if (!found.add(n)) {
	report("duplicate", n, i);
	}
	if (mine != n) {
	report("ouf of order", n, i);
	}
	mine++;
	}
	} else {
	report("gap", mine, i);
	}
	}
	for (long i = 1; i <= count; i++) {
	if (!found.contains(i)) {
	report("missing", i, -1);
	}
	}

	boolean error = false;
	error \|= reportTotal("duplicate");
	error \|= reportTotal("out of order");
	error \|= reportTotal("missing");
	error \|= reportTotal("gap");
	return error;
	}

	private void report(String type, long n, long i) {
	Long cnt = reported.get(type);
	if (cnt == null) {
	System.out.println("First " + type + ": " + n + " pos(" + i + ")");
	cnt = (long) 0;
	}
	reported.put(type, ++cnt);
	}

	private boolean reportTotal(String type) {
	Long cnt = reported.get(type);
	if (cnt != null) {
	System.out.println("Total " + type + "s: " + cnt);
	return true;
	}
	return false;
	}

	public static class OneThread implements Runnable {
	public FsStoreTest test = new FsStoreTest();
	public Boolean result;

	@Override
	public void run() {
	try {
	test.setUp();
	long head = test.store.getHead();
	test.count();
	result = !test.verify(head);
	} catch (Exception e) {
	}
	if (threads.size() > 1) {
	if (result != null && result) {
	System.out.println("\nPASS " + test.id);
	} else {
	result = false;
	System.out.println("\nFAIL " + test.id);
	}
	}
	}
	}

	/**
	* First, make the junit jar easily available
	*
	* <p>ln -s ~/.m2/repository/junit/junit/4.8.1/junit-4.8.1.jar target
	*
	* <p>To run type:
	*
	* <p>java -cp target/classes:target/test-classes:target/junit-4.8.1.jar \
	* com.googlesource.gerrit.plugins.events.fsstore.FsStoreTest [--id store-id] [dir [count]]
	*
	* <p>Note: if you do not specify <dir>, it will create a directory under /tmp
	*
	* <p>Local(spinning) 1 worker 1M 28m2s ~17ms/event find events\|wc -l .97 rm -rf 30s
	*/
	public static void main(String[] argv) throws Exception {
	List<String> args = new LinkedList<>();
	for (String arg : argv) {
	args.add(arg);
	}

	setThreadCount(1);
	int thread = 0;
	setSubmitMarker(".");
	for (Iterator<String> it = args.iterator(); it.hasNext(); ) {
	String arg = it.next();
	if (it.hasNext()) {
	if ("--id".equals(arg)) {
	it.remove();
	setId(thread++, it.next());
	it.remove();
	} else if ("-j".equals(arg) \|\| "--threads".equals(arg)) {
	it.remove();
	setThreadCount(new Integer(it.next()));
	it.remove();
	}
	}
	}

	if (args.size() > 0) {
	base = Paths.get(args.remove(0));
	}

	if (args.size() > 0) {
	setCount(Long.parseLong(args.remove(0)));
	}

	runThreads();

	if (getResult()) {
	System.out.println("\nPASS");
	} else {
	System.out.println("\nFAIL");
	}
	}

	private static void runThreads()
	throws IllegalArgumentException, InterruptedException, SecurityException {
	List<Thread> running = new LinkedList<>();

	for (OneThread t : threads) {
	Thread thread = new Thread(t);
	thread.start();
	running.add(thread);
	}

	for (Thread thread : running) {
	thread.join();
	}
	}

	private static boolean getResult() {
	for (OneThread t : threads) {
	if (t.result == null \|\| !t.result) {
	return false;
	}
	}
	return true;
	}

	private static void setCount(long count) {
	for (OneThread t : threads) {
	t.test.count = count;
	}
	}

	private static void setSubmitMarker(String marker) {
	for (OneThread t : threads) {
	t.test.submitMarker = marker;
	}
	}

	private static void setId(int n, String id) {
	OneThread t = threads.get(n);
	t.test.id = id;
	t.test.submitMarker += id + ".";
	}

	private static void setThreadCount(int n) {
	/* Use a common FsStore for all threads so that synchronized will work across them. */
	FsStore commonStore = threads.get(0).test.store;
	while (threads.size() < n) {
	OneThread t = new OneThread();
	t.test.store = commonStore;
	threads.add(t);
	}
	}
	}