fix IString replace method

Author: lecousin

net.lecousin.core/src/main/java/net/lecousin/framework/text/ByteArrayStringIso8859.java

@@ -334,17 +334,17 @@ public ByteArrayStringIso8859 replace(int start, int end, CharSequence replace)
 		int l = replace.length();
 		int l2 = end - start + 1;
 		if (l == l2) {
-			overwrite(start, replace);
+			overwrite(this.start + start, replace);
 			return this;
 		}
 		if (l < l2) {
 			overwrite(this.start + start, replace);
-			System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - end);
+			System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - this.start - end);
 			this.end -= l2 - l;
 			return this;
 		}
 		enlarge(Math.min(l - l2, 16));
-		System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - end);
+		System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - this.start - end);
 		overwrite(this.start + start, replace);
 		this.end += l - l2;
 		return this;

net.lecousin.core/src/main/java/net/lecousin/framework/text/CharArrayString.java

@@ -316,12 +316,12 @@ public CharArrayString replace(int start, int end, CharSequence replace) {
 		}
 		if (l < l2) {
 			overwrite(this.start + start, replace);
-			System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - end);
+			System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - this.start - end);
 			this.end -= l2 - l;
 			return this;
 		}
 		enlarge(Math.min(l - l2, 16));
-		System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - end);
+		System.arraycopy(chars, this.start + start + l2, chars, this.start + start + l, this.end - this.start - end);
 		overwrite(this.start + start, replace);
 		this.end += l - l2;
 		return this;

net.lecousin.core/src/main/java/net/lecousin/framework/text/IString.java

@@ -174,7 +174,9 @@ default String asString() {
 
 	/** Convert into an array of character arrays. */
 	default char[][] asCharacters() {
-		char[] chars = new char[length()];
+		int l = length();
+		if (l == 0) return new char[0][];
+		char[] chars = new char[l];
 		fill(chars);
 		return new char[][] { chars };
 	}

net.lecousin.core/src/test/java/net/lecousin/framework/core/test/io/TestIOError.java

@@ -14,6 +14,7 @@
 import net.lecousin.framework.core.test.LCCoreAbstractTest;
 import net.lecousin.framework.io.IO;
 import net.lecousin.framework.io.IOUtil;
+import net.lecousin.framework.io.data.ByteArray;
 import net.lecousin.framework.mutable.MutableBoolean;
 import net.lecousin.framework.util.ConcurrentCloseable;
 import net.lecousin.framework.util.Pair;
@@ -189,6 +190,155 @@ public AsyncSupplier<Long, IOException> getSizeAsync() {
 
 	}
 
+	/** Return an IOException after first bytes. */
+	public static class ReadableErrorAfterBeginning extends ConcurrentCloseable<IOException> implements IO.Readable, IO.Readable.Buffered {
+
+		public ReadableErrorAfterBeginning(ByteArray beginning) {
+			this.beginning = beginning;
+		}
+		
+		protected IOException error = new IOException("it's normal");
+		protected ByteArray beginning;
+		
+		@Override
+		public String getSourceDescription() {
+			return getClass().getSimpleName();
+		}
+
+		@Override
+		public IO getWrappedIO() {
+			return null;
+		}
+
+		@Override
+		public void setPriority(byte priority) {
+		}
+
+		@Override
+		public TaskManager getTaskManager() {
+			return Threading.getCPUTaskManager();
+		}
+
+		@Override
+		public int read() throws IOException {
+			if (!beginning.hasRemaining())
+				throw error;
+			return beginning.get() & 0xFF;
+		}
+
+		@Override
+		public int read(byte[] buffer, int offset, int len) throws IOException {
+			if (!beginning.hasRemaining())
+				throw error;
+			int l = Math.min(len, beginning.remaining());
+			beginning.get(buffer, offset, l);
+			return l;
+		}
+
+		@Override
+		public int readFully(byte[] buffer) throws IOException {
+			return read(buffer, 0, buffer.length);
+		}
+
+		@Override
+		public int skip(int skip) throws IOException {
+			if (!beginning.hasRemaining())
+				throw error;
+			int l = Math.min(skip, beginning.remaining());
+			beginning.moveForward(l);
+			return l;
+		}
+
+		@Override
+		public AsyncSupplier<ByteBuffer, IOException> readNextBufferAsync(Consumer<Pair<ByteBuffer, IOException>> ondone) {
+			if (!beginning.hasRemaining())
+				return IOUtil.error(error, ondone);
+			ByteBuffer b = beginning.toByteBuffer();
+			beginning.goToEnd();
+			return IOUtil.success(b, ondone);
+		}
+		
+		@Override
+		public ByteBuffer readNextBuffer() throws IOException {
+			if (!beginning.hasRemaining())
+				throw error;
+			ByteBuffer b = beginning.toByteBuffer();
+			beginning.goToEnd();
+			return b;
+		}
+
+		@Override
+		public int readAsync() throws IOException {
+			return read();
+		}
+
+		@Override
+		public AsyncSupplier<Integer, IOException> readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer, IOException>> ondone) {
+			if (!beginning.hasRemaining())
+				return IOUtil.error(error, ondone);
+			int l = Math.min(beginning.remaining(), buffer.remaining());
+			buffer.put(beginning.getArray(), beginning.getCurrentArrayOffset(), l);
+			beginning.moveForward(l);
+			return IOUtil.success(Integer.valueOf(l), ondone);
+		}
+
+		@Override
+		public IAsync<IOException> canStartReading() {
+			return new Async<>(true);
+		}
+
+		@Override
+		public int readSync(ByteBuffer buffer) throws IOException {
+			if (!beginning.hasRemaining())
+				throw error;
+			int l = Math.min(beginning.remaining(), buffer.remaining());
+			buffer.put(beginning.getArray(), beginning.getCurrentArrayOffset(), l);
+			beginning.moveForward(l);
+			return l;
+		}
+
+		@Override
+		public AsyncSupplier<Integer, IOException> readAsync(ByteBuffer buffer, Consumer<Pair<Integer, IOException>> ondone) {
+			return readFullySyncIfPossible(buffer, ondone);
+		}
+
+		@Override
+		public int readFullySync(ByteBuffer buffer) throws IOException {
+			return readSync(buffer);
+		}
+
+		@Override
+		public AsyncSupplier<Integer, IOException> readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer, IOException>> ondone) {
+			return readAsync(buffer, ondone);
+		}
+
+		@Override
+		public long skipSync(long n) throws IOException {
+			return skip((int)n);
+		}
+
+		@Override
+		public AsyncSupplier<Long, IOException> skipAsync(long n, Consumer<Pair<Long, IOException>> ondone) {
+			return IOUtil.skipAsyncUsingSync(this, n, ondone);
+		}
+
+		@Override
+		public byte getPriority() {
+			return Task.PRIORITY_NORMAL;
+		}
+
+		@Override
+		protected IAsync<IOException> closeUnderlyingResources() {
+			return new Async<>(true);
+		}
+
+		@Override
+		protected void closeResources(Async<IOException> ondone) {
+			ondone.unblock();
+		}
+		
+	}
+	
 	protected abstract IO.Readable getReadable(ReadableAlwaysError io) throws Exception;
 
 	protected abstract IO.Readable.Buffered getReadableBuffered(ReadableAlwaysError io) throws Exception;

net.lecousin.core/src/test/java/net/lecousin/framework/core/tests/text/TestByteArrayStringIso8859Buffer.java

@@ -14,7 +14,7 @@ public class TestByteArrayStringIso8859Buffer extends TestArrayStringBuffer<Byte
 
 	@Override
 	protected ByteArrayStringIso8859Buffer createString(String s) {
-		return new ByteArrayStringIso8859Buffer(s);
+		return s.length() > 0 ? new ByteArrayStringIso8859Buffer(s) : new ByteArrayStringIso8859Buffer();
 	}
 
 	@Override