tests (encapsulation)

assira/src/main/java/net/ranides/assira/io/BufferAdapter.java

@@ -102,9 +102,9 @@ public final class BufferAdapter {
         return prv;
     }
     
-    static class BChannel implements SeekableByteChannel {
+    private static class BChannel implements SeekableByteChannel {
         
-        ByteBuffer buffer;
+        private ByteBuffer buffer;
 
         public BChannel(ByteBuffer buffer) {
             this.buffer = buffer;
@@ -244,9 +244,9 @@ public final class BufferAdapter {
     
     }
     
-    static class BOStream extends OutputStream {
+    private static class BOStream extends OutputStream {
         
-        ByteBuffer buffer;
+        private ByteBuffer buffer;
 
         public BOStream(ByteBuffer buffer) {
             this.buffer = buffer;
@@ -342,11 +342,11 @@ public final class BufferAdapter {
         
     }
     
-    static class CWriter extends Writer {
+    private static class CWriter extends Writer {
         
         private static final CharBuffer EMPTY = CharBuffer.allocate(0);
         
-        CharBuffer buffer;
+        private CharBuffer buffer;
 
         public CWriter(CharBuffer buffer) {
             this.buffer = buffer;
@@ -435,10 +435,10 @@ public final class BufferAdapter {
         
     }
     
-    static class BWriter extends Writer {
+    private static class BWriter extends Writer {
         
-        Charset charset;
-        ByteBuffer buffer;
+        private Charset charset;
+        private ByteBuffer buffer;
         
         public BWriter(ByteBuffer buffer, Charset charset) {
             this.buffer = buffer;

assira/src/main/java/net/ranides/assira/io/ChannelAdapter.java

@@ -55,11 +55,11 @@ public final class ChannelAdapter {
         }
     }
     
-    static class AChannel implements SeekableByteChannel {
+    private static class AChannel implements SeekableByteChannel {
         
-        byte[] array;
-        int position;
-        int limit;
+        private byte[] array;
+        private int position;
+        private int limit;
 
         public AChannel(byte[] array) { // NOPMD w końcu to wrapper, nie?
             this.array = array;
@@ -139,10 +139,10 @@ public final class ChannelAdapter {
         
     }
     
-    static class CSChannel implements SeekableByteChannel {
+    private static class CSChannel implements SeekableByteChannel {
         
-        CharSequence chars;
-        int position;
+        private CharSequence chars;
+        private int position;
         private int limit;
 
         public CSChannel(CharSequence chars) { // NOPMD w końcu to wrapper, nie?
@@ -239,11 +239,11 @@ public final class ChannelAdapter {
         
     }
     
-    static class CAChannel implements SeekableByteChannel {
+    private static class CAChannel implements SeekableByteChannel {
         
-        char[] chars;
-        int position;
-        int limit;
+        private char[] chars;
+        private int position;
+        private int limit;
 
         public CAChannel(char[] chars) { // NOPMD w końcu to wrapper, nie?
             this.chars = chars;

assira/src/main/java/net/ranides/assira/io/DataAdapter.java

@@ -58,9 +58,9 @@ public final class DataAdapter {
         return new DIReader(input);
     }
     
-    static class DOStream extends OutputStream {
+    private static class DOStream extends OutputStream {
 
-        final DataOutput odata;
+        private final DataOutput odata;
 
         public DOStream(DataOutput odata) {
             this.odata = odata;
@@ -150,9 +150,9 @@ public final class DataAdapter {
 
     }
     
-    static class DOWriter extends Writer {
+    private static class DOWriter extends Writer {
         
-        final DataOutput odata;
+        private final DataOutput odata;
 
         public DOWriter(DataOutput odata) {
             this.odata = odata;
@@ -219,11 +219,11 @@ public final class DataAdapter {
         
     }
     
-    static class DIReader extends Reader {
+    private static class DIReader extends Reader {
+        
+        private final DataInput idata;
+        private Character last;
         
-        Character last;
-        final DataInput idata;
-
         public DIReader(DataInput idata) {
             this.idata = idata;
         }

assira/src/main/java/net/ranides/assira/test/TAdapter.java

@@ -0,0 +1,33 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.test;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+import net.ranides.assira.collection.maps.IdentMap;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class TAdapter<R,T> extends IdentMap<R, T> {
+    
+    public R map(T value, Function<T, R> adapter) {
+        R key = adapter.apply(value);
+        put(key, value);
+        return key;
+    }
+    
+    public Supplier<R> map(Supplier<T> supplier, Function<T, R> adapter) {
+        return () -> map(supplier.get(), adapter);
+    }
+    
+    public Function<int[], R> map(Function<int[], T> generator, Function<T, R> adapter) {
+        return (array) -> map(generator.apply(array), adapter);
+    }
+    
+}

assira/src/main/java/net/ranides/assira/text/StrBuilder.java

@@ -446,7 +446,7 @@ public final class StrBuilder implements CharSequence, Appendable, Serializable
         return new SReader();
     }
     
-    final class SReader extends Reader {
+    private final class SReader extends Reader {
         
         private int pos;
         private int mark;
@@ -508,11 +508,7 @@ public final class StrBuilder implements CharSequence, Appendable, Serializable
         public void reset() {
             pos = mark;
         }
-        
-        StrBuilder parent() {
-            return StrBuilder.this;
-        }
-        
+
     }
 
     private final class SWriter extends Writer {

assira/src/test/java/net/ranides/assira/io/BufferAdapterTest.java

@@ -21,8 +21,10 @@ import java.util.List;
 import java.util.function.Function;
 import net.ranides.assira.ContractTesters;
 import net.ranides.assira.collection.arrays.ArrayUtils;
+import net.ranides.assira.collection.maps.IdentMap;
 import org.junit.Test;
 import static net.ranides.assira.junit.NewAssert.*;
+import net.ranides.assira.test.TAdapter;
 import net.ranides.assira.text.Charsets;
 import net.ranides.assira.text.StringUtils;
 
@@ -34,27 +36,34 @@ public class BufferAdapterTest {
     
     @Test
     public void testAsWriter_CharBuffer() throws IOException {
+        TAdapter<Writer, CharBuffer> map = new TAdapter<>();
+        
         Function<Writer, String> mr = (ostream) -> {
-            CharBuffer b = ((BufferAdapter.CWriter)ostream).buffer;
+            CharBuffer b = map.get(ostream);
             return new String(b.array(), 0, b.position());
         };
         
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> BufferAdapter.asWriter(CharBuffer.allocate(1024)));
+            .param("writer.chars!", mr)
+            .run(map.map(() -> CharBuffer.allocate(1024), BufferAdapter::asWriter));
         assertTrue(true);
     }
     
     @Test
     public void testAsWriter_ByteBuffer() throws IOException {
+        TAdapter<Writer, ByteBuffer> map = new TAdapter<>();
+        
         Function<Writer, String> mr = (ostream) -> {
-            ByteBuffer b = ((BufferAdapter.BWriter)ostream).buffer;
+            ByteBuffer b = map.get(ostream);
             return new String(b.array(), 0, b.position(), Charsets.UTF16LE);
         };
         
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> BufferAdapter.asWriter(ByteBuffer.allocate(1024), Charsets.UTF16LE));
+            .param("writer.chars!", mr)
+            .run(map.map(
+                () -> ByteBuffer.allocate(1024), 
+                c -> BufferAdapter.asWriter(c, Charsets.UTF16LE)
+            ));
         assertTrue(true);
     }
     
@@ -95,14 +104,16 @@ public class BufferAdapterTest {
     
     @Test
     public void testOStream() {
+        TAdapter<OutputStream, ByteBuffer> map = new TAdapter<>();
+        
         Function<OutputStream, byte[]> mr = (ostream) -> {
-            ByteBuffer bos = ((BufferAdapter.BOStream)ostream).buffer;
+            ByteBuffer bos = map.get(ostream);
             return ArrayUtils.slice(bos.array(), 0, bos.position());
         };
        
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> BufferAdapter.asOutputStream(ByteBuffer.allocate(1024)));
+            .param("ostream.bytes!", mr)
+            .run(map.map(() -> ByteBuffer.allocate(1024), BufferAdapter::asOutputStream));
         assertTrue(true);
 
     }
@@ -130,7 +141,6 @@ public class BufferAdapterTest {
     public void testAsInput() throws IOException {
         Function<int[], InputStream> mr = (array) -> {
             ByteBuffer bb = ByteBuffer.wrap(ints2bytes(array));
-            bb.position(0);
             return BufferAdapter.asInputStream(bb);
         };
         ContractTesters.runner()
@@ -141,8 +151,7 @@ public class BufferAdapterTest {
     @Test
     public void testAsReader_CharBuffer() throws IOException {
         Function<int[], Reader> mr = (array) -> {
-            CharBuffer cb = CharBuffer.wrap(StringUtils.fromCodePoints(array));
-            cb.position(0);
+            CharBuffer cb = CharBuffer.wrap(ints2str(array));
             return BufferAdapter.asReader(cb);
         };
         ContractTesters.runner()
@@ -155,8 +164,7 @@ public class BufferAdapterTest {
     @Test
     public void testAsReader_ByteBuffer() throws IOException {
         Function<int[], Reader> mr = (array) -> {
-            ByteBuffer cb = ByteBuffer.wrap(StringUtils.fromCodePoints(array).getBytes(Charsets.UTF16LE));
-            cb.position(0);
+            ByteBuffer cb = ByteBuffer.wrap(ints2str(array).getBytes(Charsets.UTF16LE));
             return BufferAdapter.asReader(cb, Charsets.UTF16LE);
         };
         ContractTesters.runner()
@@ -168,14 +176,16 @@ public class BufferAdapterTest {
     
     @Test
     public void testAsChannel() {
+        TAdapter<ByteChannel, ByteBuffer> map = new TAdapter<>();
+        
         Function<ByteChannel, byte[]> mr = (channel) -> {
-            ByteBuffer bos = ((BufferAdapter.BChannel)channel).buffer;
+            ByteBuffer bos = map.get(channel);
             return ArrayUtils.slice(bos.array(), 0, bos.position());
         };
         ContractTesters.runner()
-            .param("output!", mr)
+            .param("channel.bytes!", mr)
             .debug(true)
-            .run(() -> BufferAdapter.asChannel(ByteBuffer.allocate(1024)));
+            .run(map.map(()->ByteBuffer.allocate(1024), BufferAdapter::asChannel));
         assertTrue(true);
     }
     
@@ -232,6 +242,10 @@ public class BufferAdapterTest {
         });
     }
     
+    private static String ints2str(int[] array) {
+        return StringUtils.fromCodePoints(array);
+    }
+    
     private static byte[] ints2bytes(int[] array) {
         byte[] ba = new byte[array.length];
         for(int i=0; i<ba.length; i++) {

assira/src/test/java/net/ranides/assira/io/ChannelAdapterTest.java

@@ -10,15 +10,12 @@ import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.CharBuffer;
 import java.nio.channels.ByteChannel;
 import java.nio.channels.SeekableByteChannel;
-import java.util.Arrays;
 import java.util.function.Function;
 import net.ranides.assira.ContractTesters;
 import net.ranides.assira.collection.arrays.ArrayUtils;
-import net.ranides.assira.text.Charsets;
+import net.ranides.assira.test.TAdapter;
 import net.ranides.assira.text.StringUtils;
 import net.ranides.assira.trace.ExceptionUtils;
 import org.junit.Test;
@@ -29,68 +26,97 @@ import static org.junit.Assert.*;
  * @author Ranides Atterwim <ranides@gmail.com>
  */
 public class ChannelAdapterTest {
-
+    
+    // @todo (assira #0) ChannelAdapterTester: rewrite logic
+    
     @Test
     public void testWrap_Contract_ByteBuffer() {
+        TAdapter<ByteChannel, ByteBuffer> map = new TAdapter<>();
+        
         Function<ByteChannel, byte[]> mr = (channel) -> {
-            ByteBuffer bos = ((BufferAdapter.BChannel)channel).buffer;
+            ByteBuffer bos = map.get(channel);
             return ArrayUtils.slice(bos.array(), 0, bos.position());
         };
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> ChannelAdapter.wrap(ByteBuffer.allocate(1024)));
+            .param("channel.bytes!", mr)
+            .run(() -> {
+                ByteBuffer b = ByteBuffer.allocate(1024);
+                ByteChannel c = ChannelAdapter.wrap(b);
+                map.put(c, b);
+                return c;
+            });
         assertTrue(true);
         
     }
     
     @Test
     public void testWrap_Contract_ByteArray() {
-        Function<ByteChannel, byte[]> mr = (channel) -> {
-            ChannelAdapter.AChannel ac = (ChannelAdapter.AChannel)channel;
-            return ArrayUtils.slice(ac.array, 0, ac.position);
+        TAdapter<SeekableByteChannel, byte[]> map = new TAdapter<>();
+        
+        Function<SeekableByteChannel, byte[]> mr = (channel) -> {
+            try {
+                byte[] array = map.get(channel);
+                return ArrayUtils.slice(array, 0, (int)channel.position());
+            } catch(IOException cause) {
+                throw ExceptionUtils.rethrow(cause);
+            }
         };
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> ChannelAdapter.wrap(new byte[1024]));
+            .param("channel.bytes!", mr)
+            .run(map.map(()->new byte[1024], ChannelAdapter::wrap));
         assertTrue(true);
     }
     
     @Test
     public void testWrap_Contract_CharBuffer() throws IOException {
-        Function<ByteChannel, byte[]> mr = (channel) -> {
-            ChannelAdapter.CSChannel ac = (ChannelAdapter.CSChannel)channel;
-            return chars2bytes(ac.chars, ac.position);
+        TAdapter<SeekableByteChannel, CharSequence> map = new TAdapter<>();
+        
+        Function<SeekableByteChannel, byte[]> mr = (channel) -> {
+            try {
+                CharSequence c = map.get(channel);
+                return chars2bytes(c, (int)channel.position());
+            } catch(IOException cause) {
+                throw ExceptionUtils.rethrow(cause);
+            }
         };
         ContractTesters.runner()
             .ignore("ChannelTester.functionalWrite")
             .ignore("ChannelTester.functionalWriteRandom")
             .ignore("ChannelTester.functionalWriteEOF")
-            .param("output!", mr)
-            .run(() -> ChannelAdapter.wrap(CharBuffer.allocate(512)));
+            .param("channel.bytes!", mr)
+            .run(map.map(StringUtils::fromCodePoints, ChannelAdapter::wrap));
         assertTrue(true);
     }
     
     @Test
     public void testWrap_Contract_CharArray() throws IOException {
-        Function<ByteChannel, byte[]> mr = (channel) -> {
-            ChannelAdapter.CAChannel ac = (ChannelAdapter.CAChannel)channel;
-            return chars2bytes(StringUtils.wrap(ac.chars), ac.position);
+        TAdapter<SeekableByteChannel, char[]> map = new TAdapter<>();
+        
+        Function<SeekableByteChannel, byte[]> mr = (channel) -> {
+            try {
+                char[] chars = map.get(channel);
+                return chars2bytes(StringUtils.wrap(chars), (int)channel.position());
+            } catch(IOException cause) {
+                throw ExceptionUtils.rethrow(cause);
+            }
+            
         };
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> ChannelAdapter.wrap(new char[512]));
+            .param("channel.bytes!", mr)
+            .run(map.map(()->new char[512], ChannelAdapter::wrap));
         assertTrue(true);
     }
 
+    
     private static byte[] chars2bytes(CharSequence chars, int bytes) {
         try {
             ByteArrayOutputStream os = new ByteArrayOutputStream();
             DataOutputStream ds = new DataOutputStream(os);
-            for(int i=0, n=bytes/2; i<n; i++) {
+            for(int i=0, n= bytes/2; i<n; i++) {
                 ds.writeChar(chars.charAt(i));
             }
             if(0 != bytes %2) {
-                ds.write(chars.charAt(bytes/2) >> 8);
+                ds.write(chars.charAt( bytes/2) >> 8);
             }
 
             return os.toByteArray();

assira/src/test/java/net/ranides/assira/io/DataAdapterTest.java

@@ -8,7 +8,6 @@ package net.ranides.assira.io;
 
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
-import java.io.DataOutput;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -19,11 +18,11 @@ import java.util.function.BiConsumer;
 import java.util.function.Function;
 import net.ranides.assira.ContractTesters;
 import net.ranides.assira.collection.arrays.ArrayUtils;
+import net.ranides.assira.test.TAdapter;
 import net.ranides.assira.text.Charsets;
 import static org.junit.Assert.*;
 import org.junit.Test;
 import net.ranides.assira.text.StringUtils;
-import net.ranides.assira.trace.ExceptionUtils;
 
 /**
  *
@@ -31,32 +30,36 @@ import net.ranides.assira.trace.ExceptionUtils;
  */
 public class DataAdapterTest {
     
-    // @todo (assira #0) DataBuffer implements DataInput, DataOutput
+    // @todo (assira #3) DataBuffer implements DataInput, DataOutput
     
     @Test
     public void testWriter() {
-        
+        TAdapter<Writer, ByteArrayOutputStream> map = new TAdapter<>();
+
         Function<Writer, String> mr = (ostream) -> {
-            DataOutput odata = ((DataAdapter.DOWriter)ostream).odata;
-            byte[] data = ((ByteArrayDataOutput)odata).getBytes();
-            return new String(data, Charsets.UTF16BE);
+            return new String(map.get(ostream).toByteArray(), Charsets.UTF16BE);
         };
         ContractTesters.runner()
             .debug(true)
-            .param("output!", mr)
-            .run(() -> DataAdapter.asWriter(new ByteArrayDataOutput()));
+            .param("writer.chars!", mr)
+            .run(map.map(()->new ByteArrayOutputStream(), a -> DataAdapter.asWriter(new DataOutputStream(a))));
         assertTrue(true);
     }
     
     @Test
     public void testOStream() {
+        TAdapter<OutputStream, ByteArrayOutputStream> map = new TAdapter<>();
+        
         Function<OutputStream, byte[]> mr = (ostream) -> {
-            return ((ByteArrayDataOutput)((DataAdapter.DOStream)ostream).odata).getBytes();
+            return map.get(ostream).toByteArray();
         };
         
         ContractTesters.runner()
-            .param("output!", mr)
-            .run(() -> DataAdapter.asOutput(new ByteArrayDataOutput()));
+            .param("ostream.bytes!", mr)
+            .run(map.map(
+                () -> new ByteArrayOutputStream(), 
+                a -> DataAdapter.asOutput(new DataOutputStream(a))
+            ));
         assertTrue(true);
 
     }
@@ -64,7 +67,7 @@ public class DataAdapterTest {
     @Test
     public void testInput() throws IOException {
         Function<int[], InputStream> mr = (array) -> {
-            return DataAdapter.asInput(new ByteArrayDataInput().appendBytes(array));
+            return DataAdapter.asInput(new DataInputStream(new ByteArrayInput().append(array)));
         };
         
         ContractTesters.runner()
@@ -74,51 +77,47 @@ public class DataAdapterTest {
     
     @Test
     public void testAsReader() throws IOException {
-        Function<int[], Reader> mr = (array) -> {
-            return DataAdapter.asReader(new ByteArrayDataInput().appendU16(array));
-        };
-        BiConsumer<Reader, String> ar = (r, value) -> {
-            DataAdapter.DIReader ri = (DataAdapter.DIReader)r;
-            ByteArrayDataInput di = (ByteArrayDataInput)ri.idata;
+        TAdapter<Reader, ByteArrayInput> map = new TAdapter<>();
+        
+        BiConsumer<Reader, String> ar = (reader, value) -> {
+            ByteArrayInput di = map.get(reader);
             di.appendU16(value);
         };
         ContractTesters.runner()
             .ignore("ReaderTester.mark")
             .param("reader.appender!", ar)
-            .run(mr);
+            .run(map.map(array -> new ByteArrayInput().appendU16(array), 
+                (a) -> DataAdapter.asReader(new DataInputStream(a))
+            ));
         assertTrue(true);
     }
     
-    private static final class ByteArrayDataInput extends DataInputStream {
-
-        public ByteArrayDataInput() {
-            super(new ByteArrayInput());
-        }
+    private static final class ByteArrayInput extends InputStream  {
+        
+        byte[] buffer = new byte[0];
+        int position = 0;
         
-        public ByteArrayDataInput appendU16(int[] value) {
-            return appendU16(StringUtils.fromCodePoints(value));
-        }
         
-        public ByteArrayDataInput appendU16(String value) {
-            return appendBytes(value.getBytes(Charsets.UTF16BE));
+        public ByteArrayInput appendU16(int[] array) {
+            return appendU16(StringUtils.fromCodePoints(array));
         }
+                
+        public ByteArrayInput appendU16(String value) {
+            return append(value.getBytes(Charsets.UTF16BE));
+        }                
         
-        public ByteArrayDataInput appendBytes(int[] value) {
-            return appendBytes(ints2bytes(value));
+        public ByteArrayInput append(int[] array) {
+            byte[] bytes = new byte[array.length];
+            for(int i=0; i<bytes.length; i++) {
+                bytes[i] = (byte)array[i];
+            }
+            return append(bytes);
         }
         
-        public ByteArrayDataInput appendBytes(byte[] value) {
-            ByteArrayInput si = (ByteArrayInput)in;
-            si.buffer = ArrayUtils.concat(si.buffer, value);
+        public ByteArrayInput append(byte[] value) {
+            buffer = ArrayUtils.concat(buffer, value);
             return this;
         }
-        
-    }
-    
-    private static final class ByteArrayInput extends InputStream  {
-        
-        byte[] buffer = new byte[0];
-        int position = 0;
 
         @Override
         public int read() throws IOException {
@@ -127,30 +126,4 @@ public class DataAdapterTest {
         
     }
     
-    private static final class ByteArrayDataOutput extends DataOutputStream {
-
-        public ByteArrayDataOutput() {
-            super(new ByteArrayOutputStream());
-        }
-        
-        public byte[] getBytes() {
-            try {
-                flush();
-                return ((ByteArrayOutputStream)out).toByteArray();
-            } catch(IOException cause) {
-                throw ExceptionUtils.rethrow(cause);
-            }
-        }
-        
-    }
-
-    private static byte[] ints2bytes(int[] array) {
-        byte[] ba = new byte[array.length];
-        for(int i=0; i<ba.length; i++) {
-            ba[i] = (byte)array[i];
-        }
-        return ba;
-    }
-    
-    
 }

assira/src/test/java/net/ranides/assira/io/suite/ChannelTester.java

@@ -11,7 +11,6 @@ import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.ByteChannel;
 import java.nio.channels.SeekableByteChannel;
-import java.util.Arrays;
 import java.util.function.Function;
 import javax.annotation.Resource;
 import net.ranides.assira.junit.TestContract;
@@ -23,7 +22,7 @@ import static net.ranides.assira.junit.NewAssert.*;
  */
 public class ChannelTester {
     
-    @Resource(name = "output!")
+    @Resource(name = "channel.bytes!")
     private Function<ByteChannel, byte[]> os;
     
     @TestContract

assira/src/test/java/net/ranides/assira/io/suite/OutputStreamTester.java

@@ -19,7 +19,7 @@ import org.junit.Assert;
  */
 public class OutputStreamTester {
     
-    @Resource(name = "output!")
+    @Resource(name = "ostream.bytes!")
     private Function<OutputStream, byte[]> os;
     
     @TestContract

assira/src/test/java/net/ranides/assira/io/suite/WriterTester.java

@@ -19,8 +19,8 @@ import org.junit.Assert;
  */
 public class WriterTester {
     
-    @Resource(name = "output!")
-    private Function<Writer, String> os;
+    @Resource(name = "writer.chars!")
+    private Function<Writer, String> wc;
     
     @TestContract
     public void appendBasic(Writer writer) throws IOException {
@@ -28,7 +28,7 @@ public class WriterTester {
         writer.append("ello");
         writer.append(".. world...", 2, 8);
         
-        Assert.assertEquals("Hello world", os.apply(writer));
+        Assert.assertEquals("Hello world", wc.apply(writer));
         writer.close();
     }
     
@@ -40,7 +40,7 @@ public class WriterTester {
         writer.write("....ld..", 4, 2);
         writer.write("-- EOF.....".toCharArray(), 2, 4);
 
-        Assert.assertEquals("Hello world EOF", os.apply(writer));
+        Assert.assertEquals("Hello world EOF", wc.apply(writer));
         writer.close();
     }
 

assira/src/test/java/net/ranides/assira/text/StrBuilderTest.java

@@ -17,6 +17,7 @@ import java.util.function.Function;
 import net.ranides.assira.ContractTesters;
 import net.ranides.assira.collection.arrays.NativeArray;
 import static net.ranides.assira.junit.NewAssert.*;
+import net.ranides.assira.test.TAdapter;
 import org.junit.Test;
 
 /**
@@ -464,15 +465,18 @@ public class StrBuilderTest {
     
     @Test
     public void testReader() throws IOException {
-        Function<int[], Reader> mr = (array) -> {
-            return new StrBuilder().append(StringUtils.fromCodePoints(array)).asReader();
-        };
-        BiConsumer<Reader, String> ar = (reader, text) -> {
-            ((StrBuilder.SReader)reader).parent().append(text);
+        TAdapter<Reader, StrBuilder> map = new TAdapter<>();
+        
+        Function<int[], Reader> rf = map.map(
+            (array) -> new StrBuilder().append(StringUtils.fromCodePoints(array)), 
+            s -> s.asReader()
+        );
+        BiConsumer<Reader, String> ra = (reader, text) -> {
+            map.get(reader).append(text);
         };
         ContractTesters.runner()
-            .param("reader.appender!", ar)
-            .run(mr);
+            .param("reader.appender!", ra)
+            .run(rf);
         assertTrue(true);
     }