@theia/process 1.53.0-next.55 → 1.53.0-next.64

package/src/node/multi-ring-buffer.spec.ts

@@ -1,486 +1,486 @@
-// *****************************************************************************
-// Copyright (C) 2017 Ericsson and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import * as chai from 'chai';
-import { MultiRingBuffer } from './multi-ring-buffer';
-
-const expect = chai.expect;
-
-describe('MultiRingBuffer', function (): void {
-
-    it('expect buffer to be empty initialized', function (): void {
-        const size = 2;
-        const compareTo = Buffer.from('0000', 'hex');
-        const ringBuffer = new MultiRingBuffer({ size });
-        expect(ringBuffer['buffer'].equals(compareTo)).to.be.true;
-    });
-
-    it('expect enq and deq a string with unicode characters > 1 byte and no wrap around', function (): void {
-        const ringBufferSize = 15;
-        const ringBuffer = new MultiRingBuffer({ size: ringBufferSize });
-        const buffer = '\u00bd + \u00bc = \u00be';
-        const bufferByteLength = Buffer.byteLength(buffer, 'utf8');
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(bufferByteLength);
-    });
-
-    it('expect enq and deq a string with unicode characters > 1 byte and wrap around', function (): void {
-        const buffer = '\u00bd + \u00bc = \u00be';
-        const ringBufferSize = Buffer.byteLength(buffer[buffer.length - 1]);
-        const ringBuffer = new MultiRingBuffer({ size: ringBufferSize });
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(ringBufferSize);
-
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader);
-
-        expect(ringBuffer).to.not.be.equal(undefined);
-        if (readBuffer !== undefined) {
-            expect(readBuffer).to.be.equal(buffer[buffer.length - 1].toString());
-        }
-    });
-
-    it('expect enq a string < ring buffer size ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = 'test';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(buffer.length);
-        expect(ringBuffer.empty()).to.be.equal(false);
-        const reader = ringBuffer.getReader();
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(buffer.length);
-        expect(ringBuffer.emptyForReader(reader)).to.be.equal(false);
-
-    });
-
-    it('expect deq a string < ring buffer size ', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = 'test';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader);
-        expect(ringBuffer.size()).to.be.equal(4);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-        expect(readBuffer).to.equal(buffer);
-
-    });
-
-    it('expect deq a string > ring buffer size ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = 'testabcd';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(size);
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader);
-        expect(ringBuffer.size()).to.be.equal(size);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-        expect(readBuffer).to.equal(buffer.substring(buffer.length - size));
-
-    });
-
-    it('expect enq deq enq deq a string > ring buffer size ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = '12345678';
-
-        for (let i = 0; i < 2; i++) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-
-            const reader = ringBuffer.getReader();
-            const readBuffer = ringBuffer.deq(reader);
-
-            expect(ringBuffer.size()).to.be.equal(size);
-            expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-            expect(readBuffer).to.equal(buffer.substring(buffer.length - size));
-        }
-    });
-
-    it('expect enq a string == ring buffer size then one > ring buffer size and dequeue them ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '12345678'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal(buffers[buffers.length - 1].substring(buffers[buffers.length - 1].length - size));
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq a string == ring buffer size then one < ring buffer size and dequeue them ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '123'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('45123');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq a string == ring buffer size then one < ring buffer  then one < buffer size and dequeue ', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '123', '678'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('23678');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq buffer size then enq 1 to dequeue the right value', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '1'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('23451');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq buffer size then enq 1 twice to dequeue the right value', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '1', '12345', '1'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('23451');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq buffer size of various sizes dequeue the right value', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['12345', '123', '678', '12345', '1', '12345', '123', '12', '12', '1', '12', '123', '1234', '12345', '1', '12'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-            expect(ringBuffer.size()).to.be.equal(size);
-        }
-
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('45112');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq buffer sizes < buffer size to dequeue normally', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['1', '1'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-        }
-        expect(ringBuffer.size()).to.be.equal(2);
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('11');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect enq buffer size of various sizes dequeue the right value', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffers = ['1', '1', '12', '12'];
-
-        for (const buffer of buffers) {
-            ringBuffer.enq(buffer);
-        }
-        expect(ringBuffer.size()).to.be.equal(size);
-        const reader = ringBuffer.getReader();
-        let i = 0;
-        for (const _ of buffers) {
-            const readBuffer = ringBuffer.deq(reader);
-            if (i === 0) {
-                expect(readBuffer).to.equal('11212');
-            } else {
-                expect(readBuffer).to.equal(undefined);
-            }
-            i++;
-        }
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect multiple enq and deq to deq the right values', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        ringBuffer.enq('12345');
-
-        expect(ringBuffer.size()).to.be.equal(size);
-        const reader = ringBuffer.getReader();
-        let readBuffer = ringBuffer.deq(reader);
-        expect(readBuffer).to.equal('12345');
-
-        ringBuffer.enq('123');
-        readBuffer = ringBuffer.deq(reader);
-        expect(readBuffer).to.equal('123');
-
-        ringBuffer.enq('12345');
-        readBuffer = ringBuffer.deq(reader);
-        expect(readBuffer).to.equal('12345');
-
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-    });
-
-    it('expect data from stream on enq', async function (): Promise<void> {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = 'abc';
-
-        const astream = ringBuffer.getStream();
-        const p = new Promise<void>(resolve => {
-            astream.on('data', (chunk: string) => {
-                expect(chunk).to.be.equal(buffer);
-                resolve();
-            });
-        });
-        ringBuffer.enq(buffer);
-
-        await p;
-    });
-
-    it('expect data from stream when data is already ended', async function (): Promise<void> {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = 'abc';
-        ringBuffer.enq(buffer);
-
-        const astream = ringBuffer.getStream();
-        const p = new Promise<void>(resolve => {
-            astream.on('data', (chunk: string) => {
-                expect(chunk).to.be.equal(buffer);
-                resolve();
-            });
-        });
-
-        await p;
-    });
-
-    it('expect disposing of a stream to delete it from the ringbuffer', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const astream = ringBuffer.getStream();
-        astream.dispose();
-        expect(ringBuffer.streamsSize()).to.be.equal(0);
-        expect(ringBuffer.readersSize()).to.be.equal(0);
-    });
-
-    it('expect disposing of a reader to delete it from the ringbuffer', function (): void {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const reader = ringBuffer.getReader();
-        ringBuffer.closeReader(reader);
-        expect(ringBuffer.readersSize()).to.be.equal(0);
-    });
-
-    it('expect enq a string in utf8 and get it in hex', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = 'test';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader, -1, 'hex');
-        expect(readBuffer).to.equal('74657374');
-    });
-
-    it('expect enq a string in hex and get it in utf8', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = '74657374';
-
-        ringBuffer.enq(buffer, 'hex');
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader);
-        expect(readBuffer).to.equal('test');
-    });
-
-    it('expect data from stream in hex when enq in uf8', async function (): Promise<void> {
-        const size = 5;
-        const ringBuffer = new MultiRingBuffer({ size });
-        const buffer = 'test';
-        ringBuffer.enq(buffer);
-
-        const astream = ringBuffer.getStream('hex');
-        const p = new Promise<void>(resolve => {
-            astream.on('data', (chunk: string) => {
-                expect(chunk).to.be.equal('74657374');
-                resolve();
-            });
-        });
-
-        await p;
-    });
-
-    it('expect deq a string < ring buffer size with the internal encoding in hex ', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5, encoding: 'hex' });
-        const buffer = 'test';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        const readBuffer = ringBuffer.deq(reader);
-        expect(ringBuffer.size()).to.be.equal(4);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-        expect(readBuffer).to.equal(buffer);
-
-    });
-
-    it('expect the ringbuffer to be empty if we enq an empty string', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = '';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(0);
-        expect(ringBuffer.empty()).to.be.equal(true);
-    });
-
-    it('expect an invalid reader count to be zero', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        expect(ringBuffer.sizeForReader(1)).to.be.equal(0);
-    });
-
-    it('expect an invalid reader to be empty', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        expect(ringBuffer.emptyForReader(1)).to.be.equal(true);
-    });
-
-    it('expect partially deq a string < ring buffer size ', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = 'test';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        let readBuffer = ringBuffer.deq(reader, 2);
-        expect(ringBuffer.size()).to.be.equal(4);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(2);
-        expect(readBuffer).to.equal('te');
-
-        readBuffer = ringBuffer.deq(reader, 2);
-        expect(ringBuffer.size()).to.be.equal(4);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
-        expect(readBuffer).to.equal('st');
-    });
-
-    it('expect partially deq a string < ring buffer size then enq and deq again ', function (): void {
-        const ringBuffer = new MultiRingBuffer({ size: 5 });
-        const buffer = 'test';
-        const secondBuffer = 'abcd';
-
-        ringBuffer.enq(buffer);
-        expect(ringBuffer.size()).to.be.equal(4);
-        const reader = ringBuffer.getReader();
-        let readBuffer = ringBuffer.deq(reader, 2);
-        expect(ringBuffer.size()).to.be.equal(4);
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(2);
-        expect(readBuffer).to.equal('te');
-
-        ringBuffer.enq(secondBuffer);
-        readBuffer = ringBuffer.deq(reader, 4);
-        expect(ringBuffer.size()).to.be.equal(5);
-        expect(readBuffer).to.equal('tabc');
-        expect(ringBuffer.sizeForReader(reader)).to.be.equal(1);
-
-    });
-});
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import * as chai from 'chai';
+import { MultiRingBuffer } from './multi-ring-buffer';
+
+const expect = chai.expect;
+
+describe('MultiRingBuffer', function (): void {
+
+    it('expect buffer to be empty initialized', function (): void {
+        const size = 2;
+        const compareTo = Buffer.from('0000', 'hex');
+        const ringBuffer = new MultiRingBuffer({ size });
+        expect(ringBuffer['buffer'].equals(compareTo)).to.be.true;
+    });
+
+    it('expect enq and deq a string with unicode characters > 1 byte and no wrap around', function (): void {
+        const ringBufferSize = 15;
+        const ringBuffer = new MultiRingBuffer({ size: ringBufferSize });
+        const buffer = '\u00bd + \u00bc = \u00be';
+        const bufferByteLength = Buffer.byteLength(buffer, 'utf8');
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(bufferByteLength);
+    });
+
+    it('expect enq and deq a string with unicode characters > 1 byte and wrap around', function (): void {
+        const buffer = '\u00bd + \u00bc = \u00be';
+        const ringBufferSize = Buffer.byteLength(buffer[buffer.length - 1]);
+        const ringBuffer = new MultiRingBuffer({ size: ringBufferSize });
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(ringBufferSize);
+
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader);
+
+        expect(ringBuffer).to.not.be.equal(undefined);
+        if (readBuffer !== undefined) {
+            expect(readBuffer).to.be.equal(buffer[buffer.length - 1].toString());
+        }
+    });
+
+    it('expect enq a string < ring buffer size ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = 'test';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(buffer.length);
+        expect(ringBuffer.empty()).to.be.equal(false);
+        const reader = ringBuffer.getReader();
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(buffer.length);
+        expect(ringBuffer.emptyForReader(reader)).to.be.equal(false);
+
+    });
+
+    it('expect deq a string < ring buffer size ', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = 'test';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader);
+        expect(ringBuffer.size()).to.be.equal(4);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+        expect(readBuffer).to.equal(buffer);
+
+    });
+
+    it('expect deq a string > ring buffer size ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = 'testabcd';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(size);
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader);
+        expect(ringBuffer.size()).to.be.equal(size);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+        expect(readBuffer).to.equal(buffer.substring(buffer.length - size));
+
+    });
+
+    it('expect enq deq enq deq a string > ring buffer size ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = '12345678';
+
+        for (let i = 0; i < 2; i++) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+
+            const reader = ringBuffer.getReader();
+            const readBuffer = ringBuffer.deq(reader);
+
+            expect(ringBuffer.size()).to.be.equal(size);
+            expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+            expect(readBuffer).to.equal(buffer.substring(buffer.length - size));
+        }
+    });
+
+    it('expect enq a string == ring buffer size then one > ring buffer size and dequeue them ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '12345678'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal(buffers[buffers.length - 1].substring(buffers[buffers.length - 1].length - size));
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq a string == ring buffer size then one < ring buffer size and dequeue them ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '123'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('45123');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq a string == ring buffer size then one < ring buffer  then one < buffer size and dequeue ', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '123', '678'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('23678');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq buffer size then enq 1 to dequeue the right value', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '1'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('23451');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq buffer size then enq 1 twice to dequeue the right value', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '1', '12345', '1'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('23451');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq buffer size of various sizes dequeue the right value', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['12345', '123', '678', '12345', '1', '12345', '123', '12', '12', '1', '12', '123', '1234', '12345', '1', '12'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+            expect(ringBuffer.size()).to.be.equal(size);
+        }
+
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('45112');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq buffer sizes < buffer size to dequeue normally', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['1', '1'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+        }
+        expect(ringBuffer.size()).to.be.equal(2);
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('11');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect enq buffer size of various sizes dequeue the right value', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffers = ['1', '1', '12', '12'];
+
+        for (const buffer of buffers) {
+            ringBuffer.enq(buffer);
+        }
+        expect(ringBuffer.size()).to.be.equal(size);
+        const reader = ringBuffer.getReader();
+        let i = 0;
+        for (const _ of buffers) {
+            const readBuffer = ringBuffer.deq(reader);
+            if (i === 0) {
+                expect(readBuffer).to.equal('11212');
+            } else {
+                expect(readBuffer).to.equal(undefined);
+            }
+            i++;
+        }
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect multiple enq and deq to deq the right values', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        ringBuffer.enq('12345');
+
+        expect(ringBuffer.size()).to.be.equal(size);
+        const reader = ringBuffer.getReader();
+        let readBuffer = ringBuffer.deq(reader);
+        expect(readBuffer).to.equal('12345');
+
+        ringBuffer.enq('123');
+        readBuffer = ringBuffer.deq(reader);
+        expect(readBuffer).to.equal('123');
+
+        ringBuffer.enq('12345');
+        readBuffer = ringBuffer.deq(reader);
+        expect(readBuffer).to.equal('12345');
+
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+    });
+
+    it('expect data from stream on enq', async function (): Promise<void> {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = 'abc';
+
+        const astream = ringBuffer.getStream();
+        const p = new Promise<void>(resolve => {
+            astream.on('data', (chunk: string) => {
+                expect(chunk).to.be.equal(buffer);
+                resolve();
+            });
+        });
+        ringBuffer.enq(buffer);
+
+        await p;
+    });
+
+    it('expect data from stream when data is already ended', async function (): Promise<void> {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = 'abc';
+        ringBuffer.enq(buffer);
+
+        const astream = ringBuffer.getStream();
+        const p = new Promise<void>(resolve => {
+            astream.on('data', (chunk: string) => {
+                expect(chunk).to.be.equal(buffer);
+                resolve();
+            });
+        });
+
+        await p;
+    });
+
+    it('expect disposing of a stream to delete it from the ringbuffer', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const astream = ringBuffer.getStream();
+        astream.dispose();
+        expect(ringBuffer.streamsSize()).to.be.equal(0);
+        expect(ringBuffer.readersSize()).to.be.equal(0);
+    });
+
+    it('expect disposing of a reader to delete it from the ringbuffer', function (): void {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const reader = ringBuffer.getReader();
+        ringBuffer.closeReader(reader);
+        expect(ringBuffer.readersSize()).to.be.equal(0);
+    });
+
+    it('expect enq a string in utf8 and get it in hex', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = 'test';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader, -1, 'hex');
+        expect(readBuffer).to.equal('74657374');
+    });
+
+    it('expect enq a string in hex and get it in utf8', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = '74657374';
+
+        ringBuffer.enq(buffer, 'hex');
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader);
+        expect(readBuffer).to.equal('test');
+    });
+
+    it('expect data from stream in hex when enq in uf8', async function (): Promise<void> {
+        const size = 5;
+        const ringBuffer = new MultiRingBuffer({ size });
+        const buffer = 'test';
+        ringBuffer.enq(buffer);
+
+        const astream = ringBuffer.getStream('hex');
+        const p = new Promise<void>(resolve => {
+            astream.on('data', (chunk: string) => {
+                expect(chunk).to.be.equal('74657374');
+                resolve();
+            });
+        });
+
+        await p;
+    });
+
+    it('expect deq a string < ring buffer size with the internal encoding in hex ', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5, encoding: 'hex' });
+        const buffer = 'test';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        const readBuffer = ringBuffer.deq(reader);
+        expect(ringBuffer.size()).to.be.equal(4);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+        expect(readBuffer).to.equal(buffer);
+
+    });
+
+    it('expect the ringbuffer to be empty if we enq an empty string', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = '';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(0);
+        expect(ringBuffer.empty()).to.be.equal(true);
+    });
+
+    it('expect an invalid reader count to be zero', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        expect(ringBuffer.sizeForReader(1)).to.be.equal(0);
+    });
+
+    it('expect an invalid reader to be empty', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        expect(ringBuffer.emptyForReader(1)).to.be.equal(true);
+    });
+
+    it('expect partially deq a string < ring buffer size ', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = 'test';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        let readBuffer = ringBuffer.deq(reader, 2);
+        expect(ringBuffer.size()).to.be.equal(4);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(2);
+        expect(readBuffer).to.equal('te');
+
+        readBuffer = ringBuffer.deq(reader, 2);
+        expect(ringBuffer.size()).to.be.equal(4);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(0);
+        expect(readBuffer).to.equal('st');
+    });
+
+    it('expect partially deq a string < ring buffer size then enq and deq again ', function (): void {
+        const ringBuffer = new MultiRingBuffer({ size: 5 });
+        const buffer = 'test';
+        const secondBuffer = 'abcd';
+
+        ringBuffer.enq(buffer);
+        expect(ringBuffer.size()).to.be.equal(4);
+        const reader = ringBuffer.getReader();
+        let readBuffer = ringBuffer.deq(reader, 2);
+        expect(ringBuffer.size()).to.be.equal(4);
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(2);
+        expect(readBuffer).to.equal('te');
+
+        ringBuffer.enq(secondBuffer);
+        readBuffer = ringBuffer.deq(reader, 4);
+        expect(ringBuffer.size()).to.be.equal(5);
+        expect(readBuffer).to.equal('tabc');
+        expect(ringBuffer.sizeForReader(reader)).to.be.equal(1);
+
+    });
+});