add tests

Author: lecousin

net.lecousin.core/src/main/java/net/lecousin/framework/application/libraries/classpath/DefaultLibrariesManager.java

@@ -19,7 +19,6 @@
 import net.lecousin.framework.application.ApplicationClassLoader;
 import net.lecousin.framework.application.libraries.LibrariesManager;
 import net.lecousin.framework.application.libraries.LibraryManagementException;
-import net.lecousin.framework.concurrent.CancelException;
 import net.lecousin.framework.concurrent.Executable;
 import net.lecousin.framework.concurrent.async.Async;
 import net.lecousin.framework.concurrent.async.IAsync;
@@ -232,7 +231,7 @@ public CustomExtensionPointLoader(CustomExtensionPoint ep, String filePath) {
 		private String filePath;
 
 		@Override
-		public Void execute(Task<Void, Exception> taskContext) throws Exception, CancelException {
+		public Void execute(Task<Void, Exception> taskContext) throws Exception {
 			app.getDefaultLogger().info("Loading plugin files for custom extension point " + ep.getClass().getName() + ": " + filePath);
 			Enumeration<URL> urls = acl.getResources(filePath);
 			while (urls.hasMoreElements()) {

net.lecousin.core/src/main/java/net/lecousin/framework/io/IOUtil.java

@@ -114,7 +114,7 @@ public static <T extends IO.Readable & IO.KnownSize> void readFullyKnownSize(T i
 	/** Read fully into a byte[], and unblock the given result upon completion. */
 	public static void readFullyKnownSize(IO.Readable io, int size, AsyncSupplier<byte[], IOException> result) {
 		byte[] bytes;
-		try { bytes = new byte[size]; }
+		try { bytes = ByteArrayCache.getInstance().get(size, false); }
 		catch (Exception t) {
 			result.error(IO.error(t));
 			return;

net.lecousin.core/src/main/java/net/lecousin/framework/io/bit/SimpleReadableBitIO.java

@@ -75,8 +75,8 @@ public long readBits(int n) throws IOException {
 				return getNextBits(n);
 			if (n == currentNbBits) {
 				long val = getRemainingBits();
-				currentNbBits = 0;
 				currentValue = 0;
+				currentNbBits = 0;
 				return val;
 			}
 			if (eof) throw new EOFException();

net.lecousin.core/src/main/java/net/lecousin/framework/io/buffering/BufferedReverseIOReading.java

@@ -87,15 +87,15 @@ public long getSize() {
 	@Override
 	public void setPriority(Priority priority) { io.setPriority(priority); }
 
-	@Override
-	public IO getWrappedIO() { return io; }
-	
 	@Override
 	public String getSourceDescription() { return io.getSourceDescription(); }
 
 	@Override
 	public TaskManager getTaskManager() { return Threading.getCPUTaskManager(); }
 
+	@Override
+	public IO getWrappedIO() { return io; }
+	
 	@Override
 	protected IAsync<IOException> closeUnderlyingResources() {
 		synchronized (this) {

net.lecousin.core/src/test/java/net/lecousin/framework/core/test/text/TestArrayStringBuffer.java

@@ -44,6 +44,7 @@ public void testModifications() {
 		Assert.assertEquals(0, s.substring(1).length());
 		Assert.assertEquals(0, s.substring(1, 2).length());
 		Assert.assertTrue(s == s.removeEndChars(10));
+		Assert.assertTrue(s.isEmpty());
 		try {
 			s.setCharAt(0, ' ');
 			throw new AssertionError("must throw IllegalArgumentException");
@@ -65,6 +66,20 @@ public void testModifications() {
 		cs = createString("wxcvbn");
 		check("wxcvbn7654321g", s.replace(0, 3, cs));
 		check("wxwxcvbnn7654321g", s.replace(2, 4, cs));
+		
+		s = createString("");
+		for (int i = 0; i < 100; ++i)
+			s.append("Hello");
+		Assert.assertEquals(500, s.length());
+		for (int i = 0; i < 100; ++i)
+			Assert.assertEquals("Hello", s.substring(i * 5, (i + 1) * 5).toString());
+		
+		s = createString("");
+		for (int i = 0; i < 100; ++i)
+			s.append("Hello".toCharArray(), 0, 5);
+		Assert.assertEquals(500, s.length());
+		for (int i = 0; i < 100; ++i)
+			Assert.assertEquals("Hello", s.substring(i * 5, (i + 1) * 5).toString());
 	}
 
 }

net.lecousin.core/src/test/java/net/lecousin/framework/core/tests/io/TestIOUtil.java

@@ -25,6 +25,7 @@
 import net.lecousin.framework.io.buffering.ByteArrayIO;
 import net.lecousin.framework.io.buffering.ByteBuffersIO;
 import net.lecousin.framework.io.buffering.SimpleBufferedReadable;
+import net.lecousin.framework.mutable.MutableBoolean;
 import net.lecousin.framework.progress.FakeWorkProgress;
 
 import org.junit.Assert;
@@ -187,6 +188,21 @@ public void testReadFullyUnknownSize() throws Exception {
 		Assert.assertNotNull(result.getError());
 	}
 
+	@Test
+	public void testReadFullyKnownSize() throws Exception {
+		ByteArrayIO io = new ByteArrayIO(new byte[] {0, 1, 2, 3, 4, 5, 6, 7}, "test");
+		AsyncSupplier<byte[], IOException> result = new AsyncSupplier<>();
+		IOUtil.readFully(io, result);
+		byte[] res = result.blockResult(15000);
+		Assert.assertEquals(8, res.length);
+		
+		// error
+		result = new AsyncSupplier<>();
+		IOUtil.readFully(new TestIOError.ReadableAlwaysError.KnownSizeAlwaysError(), result);
+		result.block(15000);
+		Assert.assertNotNull(result.getError());
+	}
+	
 	@Test
 	public void testReadFullyAsync() throws Exception {
 		ByteArrayInputStream in = new ByteArrayInputStream(new byte[] {0, 1, 2, 3, 4, 5, 6, 7});
@@ -195,6 +211,21 @@ public void testReadFullyAsync() throws Exception {
 		ByteBuffersIO bbio = result.blockResult(30000);
 		Assert.assertEquals(8, bbio.getSizeSync());
 		bbio.close();
+		
+		// error
+		AsyncSupplier<Integer, IOException> err = IOUtil.readFullyAsync(new TestIOError.ReadableAlwaysError(), ByteBuffer.allocate(16), null);
+		err.block(5000);
+		Assert.assertTrue(err.hasError());
+		MutableBoolean ondoneCalled = new MutableBoolean(false);
+		err = IOUtil.readFullyAsync(new TestIOError.ReadableAlwaysError(), ByteBuffer.allocate(16), r -> ondoneCalled.set(true));
+		err.block(5000);
+		Assert.assertTrue(err.hasError());
+		Assert.assertTrue(ondoneCalled.get());
+	}
+	
+	@Test
+	public void testReadFullyAsStringSync() throws Exception {
+		Assert.assertEquals("Hello World", IOUtil.readFullyAsStringSync(new ByteArrayInputStream("Hello World".getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8));
 	}
 
 	@Test
@@ -206,5 +237,5 @@ public void testErrors() throws Exception {
 		IOUtil.readFullyKnownSize(io, 4096, resultB);
 		resultB.block(15000);
 		Assert.assertNotNull(resultB.getError());
-	}	
+	}
 }

net.lecousin.core/src/test/java/net/lecousin/framework/core/tests/io/TestLinkedIOWithSubIOReadableSeekable3.java

@@ -0,0 +1,52 @@
+package net.lecousin.framework.core.tests.io;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import net.lecousin.framework.core.test.io.TestFragmented;
+import net.lecousin.framework.core.test.io.TestFragmented.FragmentedFile;
+import net.lecousin.framework.core.test.io.TestReadableSeekable;
+import net.lecousin.framework.core.test.runners.LCConcurrentRunner;
+import net.lecousin.framework.io.FileIO;
+import net.lecousin.framework.io.IO;
+import net.lecousin.framework.io.LinkedIO;
+import net.lecousin.framework.io.SubIO;
+import net.lecousin.framework.io.buffering.BufferedIO;
+import net.lecousin.framework.math.RangeLong;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(LCConcurrentRunner.Parameterized.class) @org.junit.runners.Parameterized.UseParametersRunnerFactory(LCConcurrentRunner.ConcurrentParameterizedRunnedFactory.class)
+public class TestLinkedIOWithSubIOReadableSeekable3 extends TestReadableSeekable {
+
+	@Parameters
+	public static Collection<Object[]> parameters() throws IOException {
+		return TestFragmented.generateTestCases();
+	}
+	
+	public TestLinkedIOWithSubIOReadableSeekable3(FragmentedFile f) {
+		super(f.file, f.testBuf, f.nbBuf);
+		this.f = f;
+	}
+	
+	private FragmentedFile f;
+
+	@Override
+	protected IO.Readable.Seekable createReadableSeekableFromFile(FileIO.ReadOnly file, long fileSize) throws Exception {
+		// this test may be very slow, let's add a buffered layer
+		BufferedIO buffered = new BufferedIO(file, f.realSize, 32768, 32768, false);
+		IO.Readable.Seekable[] ios = new IO.Readable.Seekable[f.fragments.size()];
+		int i = 0;
+		for (RangeLong fragment : f.fragments)
+			ios[i++] = new SubIO.Readable.Seekable.Buffered(buffered, fragment.min, fragment.getLength(), "fragment " + i, false);
+		LinkedIO.Readable.Seekable.Buffered.DeterminedSize res = new LinkedIO.Readable.Seekable.Buffered.DeterminedSize("linked IO", ios);
+		res.addCloseListener(() -> { try { buffered.close(); } catch (Exception e) {}});
+		return res;
+	}
+	
+	@Override
+	protected boolean canSetPriority() {
+		return !f.fragments.isEmpty() && f.nbBuf > 0;
+	}
+}

net.lecousin.core/src/test/java/net/lecousin/framework/core/tests/math/TestUnits.java

@@ -1,10 +1,8 @@
 package net.lecousin.framework.core.tests.math;
 
-import org.junit.Assert;
-import org.junit.Test;
-
 import net.lecousin.framework.core.test.LCCoreAbstractTest;
 import net.lecousin.framework.math.IntegerUnit;
+import net.lecousin.framework.math.IntegerUnit.ParserRegistry;
 import net.lecousin.framework.math.IntegerUnit.UnitConversionException;
 import net.lecousin.framework.math.TimeUnit;
 import net.lecousin.framework.math.TimeUnit.Day;
@@ -13,6 +11,9 @@
 import net.lecousin.framework.math.TimeUnit.Minute;
 import net.lecousin.framework.math.TimeUnit.Second;
 
+import org.junit.Assert;
+import org.junit.Test;
+
 public class TestUnits extends LCCoreAbstractTest {
 
 	@Test
@@ -106,5 +107,10 @@ public void testFakeUnit() {
 			throw new AssertionError("conversion with FakeUnit should not be possible");
 		} catch (UnitConversionException e) {}
 	}
+	
+	@Test
+	public void testParsers() {
+		Assert.assertEquals(TimeUnit.Millisecond.class, ParserRegistry.get("ms"));
+	}
 
 }