Changed the root package from net.sf.briar to org.briarproject.

briar-tests/src/org/briarproject/plugins/file/LinuxRemovableDriveFinderTest.java

@@ -0,0 +1,25 @@
+package org.briarproject.plugins.file;
+
+import org.briarproject.BriarTestCase;
+
+import org.junit.Test;
+
+public class LinuxRemovableDriveFinderTest extends BriarTestCase {
+
+	@Test
+	public void testParseMountPoint() {
+		LinuxRemovableDriveFinder f = new LinuxRemovableDriveFinder();
+		String line = "/dev/sda3 on / type ext3"
+			+ " (rw,errors=remount-ro,commit=0)";
+		assertEquals("/", f.parseMountPoint(line));
+		line = "gvfs-fuse-daemon on /home/alice/.gvfs"
+			+ " type fuse.gvfs-fuse-daemon (rw,nosuid,nodev,user=alice)";
+		assertEquals(null, f.parseMountPoint(line)); // Can't be parsed
+		line = "fusectl on /sys/fs/fuse/connections type fusectl (rw)";
+		assertEquals(null, f.parseMountPoint(line)); // Can't be parsed
+		line = "/dev/sdd1 on /media/HAZ SPACE(!) type vfat"
+			+ " (rw,nosuid,nodev,uhelper=udisks,uid=1000,gid=1000,"
+			+ "shortname=mixed,dmask=0077,utf8=1,showexec,flush)";
+		assertEquals("/media/HAZ SPACE(!)", f.parseMountPoint(line));
+	}
+}

briar-tests/src/org/briarproject/plugins/file/MacRemovableDriveFinderTest.java

@@ -0,0 +1,23 @@
+package org.briarproject.plugins.file;
+
+import org.briarproject.BriarTestCase;
+
+import org.junit.Test;
+
+public class MacRemovableDriveFinderTest extends BriarTestCase {
+
+	@Test
+	public void testParseMountPoint() {
+		MacRemovableDriveFinder f = new MacRemovableDriveFinder();
+		String line = "/dev/disk0s3 on / (local, journaled)";
+		assertEquals("/", f.parseMountPoint(line));
+		line = "devfs on /dev (local)";
+		assertEquals(null, f.parseMountPoint(line)); // Can't be parsed
+		line = "<volfs> on /.vol";
+		assertEquals(null, f.parseMountPoint(line)); // Can't be parsed
+		line = "automount -nsl [117] on /Network (automounted)";
+		assertEquals(null, f.parseMountPoint(line)); // Can't be parsed
+		line = "/dev/disk1s1 on /Volumes/HAZ SPACE(!) (local, nodev, nosuid)";
+		assertEquals("/Volumes/HAZ SPACE(!)", f.parseMountPoint(line));
+	}
+}

briar-tests/src/org/briarproject/plugins/file/PollingRemovableDriveMonitorTest.java

@@ -0,0 +1,95 @@
+package org.briarproject.plugins.file;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.briarproject.BriarTestCase;
+import org.briarproject.plugins.file.RemovableDriveMonitor.Callback;
+
+import org.junit.Test;
+
+public class PollingRemovableDriveMonitorTest extends BriarTestCase {
+
+	@Test
+	public void testOneCallbackPerFile() throws Exception {
+		// Create a finder that returns no files the first time, then two files
+		final File file1 = new File("foo");
+		final File file2 = new File("bar");
+		final RemovableDriveFinder finder = new RemovableDriveFinder() {
+
+			private AtomicBoolean firstCall = new AtomicBoolean(true);
+
+			public Collection<File> findRemovableDrives() throws IOException {
+				if(firstCall.getAndSet(false)) return Collections.emptyList();
+				else return Arrays.asList(file1, file2);
+			}
+		};
+		// Create a callback that waits for two files
+		final CountDownLatch latch = new CountDownLatch(2);
+		final List<File> detected = new ArrayList<File>();
+		Callback callback = new Callback() {
+
+			public void driveInserted(File f) {
+				detected.add(f);
+				latch.countDown();
+			}
+
+			public void exceptionThrown(IOException e) {
+				fail();
+			}
+		};
+		// Create the monitor and start it
+		final RemovableDriveMonitor monitor = new PollingRemovableDriveMonitor(
+				Executors.newCachedThreadPool(), finder, 1);
+		monitor.start(callback);
+		// Wait for the monitor to detect the files
+		assertTrue(latch.await(10, SECONDS));
+		monitor.stop();
+		// Check that both files were detected
+		assertEquals(2, detected.size());
+		assertTrue(detected.contains(file1));
+		assertTrue(detected.contains(file2));
+	}
+
+	@Test
+	public void testExceptionCallback() throws Exception {
+		// Create a finder that throws an exception the second time it's polled
+		final RemovableDriveFinder finder = new RemovableDriveFinder() {
+
+			private AtomicBoolean firstCall = new AtomicBoolean(true);
+
+			public Collection<File> findRemovableDrives() throws IOException {
+				if(firstCall.getAndSet(false)) return Collections.emptyList();
+				else throw new IOException();
+			}
+		};
+		// Create a callback that waits for an exception
+		final CountDownLatch latch = new CountDownLatch(1);
+		Callback callback = new Callback() {
+
+			public void driveInserted(File root) {
+				fail();
+			}
+
+			public void exceptionThrown(IOException e) {
+				latch.countDown();
+			}
+		};
+		// Create the monitor and start it
+		final RemovableDriveMonitor monitor = new PollingRemovableDriveMonitor(
+				Executors.newCachedThreadPool(), finder, 1);
+		monitor.start(callback);
+		assertTrue(latch.await(10, SECONDS));
+		monitor.stop();
+	}
+}

briar-tests/src/org/briarproject/plugins/file/RemovableDrivePluginTest.java

@@ -0,0 +1,360 @@
+package org.briarproject.plugins.file;
+
+import static org.briarproject.api.transport.TransportConstants.MAX_FRAME_LENGTH;
+import static org.briarproject.api.transport.TransportConstants.MIN_CONNECTION_LENGTH;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+
+import org.briarproject.BriarTestCase;
+import org.briarproject.TestFileUtils;
+import org.briarproject.TestUtils;
+import org.briarproject.api.ContactId;
+import org.briarproject.api.plugins.simplex.SimplexPluginCallback;
+import org.briarproject.api.plugins.simplex.SimplexTransportWriter;
+import org.briarproject.api.system.FileUtils;
+import org.briarproject.plugins.ImmediateExecutor;
+import org.briarproject.plugins.file.RemovableDriveMonitor.Callback;
+
+import org.jmock.Expectations;
+import org.jmock.Mockery;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RemovableDrivePluginTest extends BriarTestCase {
+
+	private final File testDir = TestUtils.getTestDirectory();
+	private final ContactId contactId = new ContactId(234);
+	private final FileUtils fileUtils = new TestFileUtils();
+
+	@Before
+	public void setUp() {
+		testDir.mkdirs();
+	}
+
+	@Test
+	public void testWriterIsNullIfNoDrivesAreFound() throws Exception {
+		final List<File> drives = Collections.emptyList();
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		assertNull(plugin.createWriter(contactId));
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testWriterIsNullIfNoDriveIsChosen() throws Exception {
+		final File drive1 = new File(testDir, "1");
+		final File drive2 = new File(testDir, "2");
+		final List<File> drives = new ArrayList<File>();
+		drives.add(drive1);
+		drives.add(drive2);
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+			oneOf(callback).showChoice(with(any(String[].class)),
+					with(any(String.class)));
+			will(returnValue(-1)); // The user cancelled the choice
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		assertNull(plugin.createWriter(contactId));
+		File[] files = drive1.listFiles();
+		assertTrue(files == null || files.length == 0);
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testWriterIsNullIfOutputDirDoesNotExist() throws Exception {
+		final File drive1 = new File(testDir, "1");
+		final File drive2 = new File(testDir, "2");
+		final List<File> drives = new ArrayList<File>();
+		drives.add(drive1);
+		drives.add(drive2);
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+			oneOf(callback).showChoice(with(any(String[].class)),
+					with(any(String.class)));
+			will(returnValue(0)); // The user chose drive1 but it doesn't exist
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		assertNull(plugin.createWriter(contactId));
+		File[] files = drive1.listFiles();
+		assertTrue(files == null || files.length == 0);
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testWriterIsNullIfOutputDirIsAFile() throws Exception {
+		final File drive1 = new File(testDir, "1");
+		final File drive2 = new File(testDir, "2");
+		final List<File> drives = new ArrayList<File>();
+		drives.add(drive1);
+		drives.add(drive2);
+		// Create drive1 as a file rather than a directory
+		assertTrue(drive1.createNewFile());
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+			oneOf(callback).showChoice(with(any(String[].class)),
+					with(any(String.class)));
+			will(returnValue(0)); // The user chose drive1 but it's not a dir
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		assertNull(plugin.createWriter(contactId));
+		File[] files = drive1.listFiles();
+		assertTrue(files == null || files.length == 0);
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testWriterIsNotNullIfOutputDirIsADir() throws Exception {
+		final File drive1 = new File(testDir, "1");
+		final File drive2 = new File(testDir, "2");
+		final List<File> drives = new ArrayList<File>();
+		drives.add(drive1);
+		drives.add(drive2);
+		// Create drive1 as a directory
+		assertTrue(drive1.mkdir());
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+			oneOf(callback).showChoice(with(any(String[].class)),
+					with(any(String.class)));
+			will(returnValue(0)); // The user chose drive1
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		assertNotNull(plugin.createWriter(contactId));
+		// The output file should exist and should be empty
+		File[] files = drive1.listFiles();
+		assertNotNull(files);
+		assertEquals(1, files.length);
+		assertEquals(0, files[0].length());
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testWritingToWriter() throws Exception {
+		final File drive1 = new File(testDir, "1");
+		final File drive2 = new File(testDir, "2");
+		final List<File> drives = new ArrayList<File>();
+		drives.add(drive1);
+		drives.add(drive2);
+		// Create drive1 as a directory
+		assertTrue(drive1.mkdir());
+
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(finder).findRemovableDrives();
+			will(returnValue(drives));
+			oneOf(callback).showChoice(with(any(String[].class)),
+					with(any(String.class)));
+			will(returnValue(0)); // The user chose drive1
+			oneOf(callback).showMessage(with(any(String.class)));
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		SimplexTransportWriter writer = plugin.createWriter(contactId);
+		assertNotNull(writer);
+		// The output file should exist and should be empty
+		File[] files = drive1.listFiles();
+		assertNotNull(files);
+		assertEquals(1, files.length);
+		assertEquals(0, files[0].length());
+		// Writing to the output stream should increase the size of the file
+		OutputStream out = writer.getOutputStream();
+		out.write(new byte[1234]);
+		out.flush();
+		out.close();
+		// Disposing of the writer should not delete the file
+		writer.dispose(false);
+		assertTrue(files[0].exists());
+		assertEquals(1234, files[0].length());
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testEmptyDriveIsIgnored() throws Exception {
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		plugin.driveInserted(testDir);
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testFilenames() {
+		Mockery context = new Mockery();
+		final Executor executor = context.mock(Executor.class);
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(executor,
+				fileUtils, callback, finder, monitor, MAX_FRAME_LENGTH, 0);
+
+		assertFalse(plugin.isPossibleConnectionFilename("abcdefg.dat"));
+		assertFalse(plugin.isPossibleConnectionFilename("abcdefghi.dat"));
+		assertFalse(plugin.isPossibleConnectionFilename("abcdefgh_dat"));
+		assertFalse(plugin.isPossibleConnectionFilename("abcdefgh.rat"));
+		assertTrue(plugin.isPossibleConnectionFilename("abcdefgh.dat"));
+		assertTrue(plugin.isPossibleConnectionFilename("ABCDEFGH.DAT"));
+
+		context.assertIsSatisfied();
+	}
+
+	@Test
+	public void testReaderIsCreated() throws Exception {
+		Mockery context = new Mockery();
+		final SimplexPluginCallback callback =
+				context.mock(SimplexPluginCallback.class);
+		final RemovableDriveFinder finder =
+				context.mock(RemovableDriveFinder.class);
+		final RemovableDriveMonitor monitor =
+				context.mock(RemovableDriveMonitor.class);
+
+		context.checking(new Expectations() {{
+			oneOf(monitor).start(with(any(Callback.class)));
+			oneOf(callback).readerCreated(with(any(FileTransportReader.class)));
+		}});
+
+		RemovableDrivePlugin plugin = new RemovableDrivePlugin(
+				new ImmediateExecutor(), fileUtils, callback, finder, monitor,
+				MAX_FRAME_LENGTH, 0);
+		plugin.start();
+
+		File f = new File(testDir, "abcdefgh.dat");
+		OutputStream out = new FileOutputStream(f);
+		out.write(new byte[MIN_CONNECTION_LENGTH]);
+		out.flush();
+		out.close();
+		assertEquals(MIN_CONNECTION_LENGTH, f.length());
+		plugin.driveInserted(testDir);
+
+		context.assertIsSatisfied();
+	}
+
+	@After
+	public void tearDown() {
+		TestUtils.deleteTestDirectory(testDir);
+	}
+}

briar-tests/src/org/briarproject/plugins/file/UnixRemovableDriveMonitorTest.java

@@ -0,0 +1,100 @@
+package org.briarproject.plugins.file;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+import org.briarproject.BriarTestCase;
+import org.briarproject.TestUtils;
+import org.briarproject.plugins.file.RemovableDriveMonitor.Callback;
+import org.briarproject.util.OsUtils;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class UnixRemovableDriveMonitorTest extends BriarTestCase {
+
+	private final File testDir = TestUtils.getTestDirectory();
+
+	@Before
+	public void setUp() {
+		testDir.mkdirs();
+	}
+
+	@Test
+	public void testNonexistentDir() throws Exception {
+		if(!(OsUtils.isLinux() || OsUtils.isMacLeopardOrNewer())) {
+			System.err.println("Warning: Skipping test");
+			return;
+		}
+		File doesNotExist = new File(testDir, "doesNotExist");
+		RemovableDriveMonitor monitor = createMonitor(doesNotExist);
+		monitor.start(new Callback() {
+
+			public void driveInserted(File root) {
+				fail();
+			}
+
+			public void exceptionThrown(IOException e) {
+				fail();
+			}
+		});
+		monitor.stop();
+	}
+
+	@Test
+	public void testOneCallbackPerFile() throws Exception {
+		if(!(OsUtils.isLinux() || OsUtils.isMacLeopardOrNewer())) {
+			System.err.println("Warning: Skipping test");
+			return;
+		}
+		// Create a callback that will wait for two files before stopping
+		final List<File> detected = new ArrayList<File>();
+		final CountDownLatch latch = new CountDownLatch(2);
+		final Callback callback = new Callback() {
+
+			public void driveInserted(File f) {
+				detected.add(f);
+				latch.countDown();
+			}
+
+			public void exceptionThrown(IOException e) {
+				fail();
+			}
+		};
+		// Create the monitor and start it
+		RemovableDriveMonitor monitor = createMonitor(testDir);
+		monitor.start(callback);
+		// Create two files in the test directory
+		File file1 = new File(testDir, "1");
+		File file2 = new File(testDir, "2");
+		assertTrue(file1.createNewFile());
+		assertTrue(file2.createNewFile());
+		// Wait for the monitor to detect the files
+		assertTrue(latch.await(5, SECONDS));
+		monitor.stop();
+		// Check that both files were detected
+		assertEquals(2, detected.size());
+		assertTrue(detected.contains(file1));
+		assertTrue(detected.contains(file2));
+	}
+
+	@After
+	public void tearDown() {
+		TestUtils.deleteTestDirectory(testDir);
+	}
+
+	private RemovableDriveMonitor createMonitor(final File dir) {
+		return new UnixRemovableDriveMonitor() {
+			@Override
+			protected String[] getPathsToWatch() {
+				return new String[] { dir.getPath() };
+			}
+		};
+	}
+}