AsciiStringMemoryTest Class — netty Architecture

Source Code

common/src/test/java/io/netty/util/AsciiStringMemoryTest.java lines 31–173

public class AsciiStringMemoryTest {
    private byte[] a;
    private byte[] b;
    private int aOffset = 22;
    private int bOffset = 53;
    private int length = 100;
    private AsciiString aAsciiString;
    private AsciiString bAsciiString;
    private final Random r = new Random();

    @BeforeEach
    public void setup() {
        a = new byte[128];
        b = new byte[256];
        r.nextBytes(a);
        r.nextBytes(b);
        aOffset = 22;
        bOffset = 53;
        length = 100;
        System.arraycopy(a, aOffset, b, bOffset, length);
        aAsciiString = new AsciiString(a, aOffset, length, false);
        bAsciiString = new AsciiString(b, bOffset, length, false);
    }

    @Test
    public void testSharedMemory() {
        ++a[aOffset];
        AsciiString aAsciiString1 = new AsciiString(a, aOffset, length, true);
        AsciiString aAsciiString2 = new AsciiString(a, aOffset, length, false);
        assertEquals(aAsciiString, aAsciiString1);
        assertEquals(aAsciiString, aAsciiString2);
        for (int i = aOffset; i < length; ++i) {
            assertEquals(a[i], aAsciiString.byteAt(i - aOffset));
        }
    }

    @Test
    public void testNotSharedMemory() {
        AsciiString aAsciiString1 = new AsciiString(a, aOffset, length, true);
        ++a[aOffset];
        assertNotEquals(aAsciiString, aAsciiString1);
        int i = aOffset;
        assertNotEquals(a[i], aAsciiString1.byteAt(i - aOffset));
        ++i;
        for (; i < length; ++i) {
            assertEquals(a[i], aAsciiString1.byteAt(i - aOffset));
        }
    }

    @Test
    public void forEachTest() throws Exception {
        final AtomicReference<Integer> aCount = new AtomicReference<Integer>(0);
        final AtomicReference<Integer> bCount = new AtomicReference<Integer>(0);
        aAsciiString.forEachByte(new ByteProcessor() {
            int i;
            @Override
            public boolean process(byte value) {
                assertEquals(value, bAsciiString.byteAt(i++), "failed at index: " + i);
                aCount.set(aCount.get() + 1);
                return true;
            }
        });
        bAsciiString.forEachByte(new ByteProcessor() {
            int i;
            @Override
            public boolean process(byte value) {
                assertEquals(value, aAsciiString.byteAt(i++), "failed at index: " + i);
                bCount.set(bCount.get() + 1);
                return true;
            }
        });
        assertEquals(aAsciiString.length(), aCount.get().intValue());
        assertEquals(bAsciiString.length(), bCount.get().intValue());
    }

    @Test
    public void forEachWithIndexEndTest() throws Exception {
        assertNotEquals(-1, aAsciiString.forEachByte(aAsciiString.length() - 1,
                1, new IndexOfProcessor(aAsciiString.byteAt(aAsciiString.length() - 1))));
    }