protobuf.js/tests/api_writer_resize.js

var tape = require("tape");

var protobuf = require("..");

var Writer       = protobuf.Writer,
    BufferWriter = protobuf.BufferWriter,
    Reader       = protobuf.Reader;

// Exercise both the browser (Uint8Array/Array) writer and the node BufferWriter.
var writers = [ [ "Writer", Writer ] ];
if (BufferWriter)
    writers.push([ "BufferWriter", BufferWriter ]);

function toArray(buf) {
    return Array.prototype.slice.call(buf);
}

// builds a length-delimited field 1 carrying `n` distinct raw bytes via fork/ldelim
function ldelimRaw(Ctor, n) {
    var pattern = [];
    for (var i = 0; i < n; ++i)
        pattern.push(i & 255);
    var buf = new Ctor().uint32(10).fork().raw(pattern).ldelim().finish();
    return { buf: buf, pattern: pattern };
}

tape.test("writer initial buffer size", function(test) {
    var initialBufferSize = Writer.initialBufferSize;
    test.equal(Writer.initialBufferSize, 128, "defaults to 128 bytes");

    Writer.initialBufferSize = 32;
    writers.forEach(function(entry) {
        test.equal(new entry[1]().buf.length, 32, entry[0] + " uses the configured size");
    });
    Writer.initialBufferSize = initialBufferSize;

    test.end();
});

tape.test("writer resize / reserve-and-move", function(test) {

    writers.forEach(function(entry) {
        var name = entry[0], Ctor = entry[1];

        test.test(name + " - length-delimited reserve vs move boundary", function(test) {
            // 1-byte length (no move), 2-byte length (move by 1), 3-byte length (move by 2)
            [ 0, 1, 127, 128, 200, 16383, 16384, 20000 ].forEach(function(n) {
                var r = ldelimRaw(Ctor, n);
                var reader = Reader.create(r.buf);
                test.equal(reader.uint32(), 10, name + " tag intact for n=" + n);
                var inner = reader.bytes();
                test.equal(inner.length, n, name + " length prefix correct for n=" + n);
                test.same(toArray(inner), r.pattern, name + " content intact after move for n=" + n);
                test.equal(reader.pos, reader.len, name + " fully consumed for n=" + n);
            });
            test.end();
        });

        test.test(name + " - minimal length varint", function(test) {
            // 128 must encode as [0x80, 0x01], never padded by the reservation
            var buf = new Ctor().uint32(10).fork().raw(new Array(128).fill(0)).ldelim().finish();
            test.same(toArray(buf).slice(0, 3), [ 10, 0x80, 0x01 ], name + " 128 -> minimal 2-byte varint");
            test.equal(buf.length, 3 + 128, name + " total length");
            test.end();
        });

        test.test(name + " - nested forks with cascading moves", function(test) {
            var inner = [], outerTail = [];
            for (var i = 0; i < 200; ++i) inner.push((i * 7) & 255);
            for (var j = 0; j < 50; ++j) outerTail.push((j * 3) & 255);
            // outer field 1 { inner field 2 = 200 bytes } + 50 trailing raw bytes
            var buf = new Ctor()
                .uint32(10).fork()
                    .uint32(18).fork().raw(inner).ldelim()
                    .raw(outerTail)
                .ldelim()
                .finish();
            var reader = Reader.create(buf);
            test.equal(reader.uint32(), 10, name + " outer tag");
            var outer = reader.bytes();
            var ri = Reader.create(outer);
            test.equal(ri.uint32(), 18, name + " inner tag");
            test.same(toArray(ri.bytes()), inner, name + " inner content intact");
            test.same(toArray(outer).slice(ri.pos), outerTail, name + " trailing content intact");
            test.end();
        });

        test.test(name + " - string fast path: multi-byte, surrogates, boundary", function(test) {
            var cases = [
                "",
                "abc",
                "ä".repeat(63),   // 126 bytes, 1-byte length, encode-then-measure, no move
                "ä".repeat(64),   // 128 bytes, 2-byte length, encode-then-measure + move
                "€".repeat(50),   // 3-byte chars, 150 bytes, move
                "😀".repeat(32),  // surrogate pairs: 64 units, 128 bytes, move
                "x".repeat(127),  // encode-then-measure, ascii, 1-byte length
                "x".repeat(128),  // precompute branch (>= threshold), ascii
                "y".repeat(5000), // precompute branch, forces buffer growth
                "🎉mixed-ä-€-text".repeat(20)
            ];
            cases.forEach(function(s) {
                var buf = new Ctor().string(s).finish();
                test.equal(Reader.create(buf).string(), s, name + " roundtrips string of " + s.length + " units");
            });
            test.end();
        });

        test.test(name + " - hybrid branches agree with reference bytes", function(test) {
            // a string just below and well above the precompute threshold must both
            // produce [minimal-length-varint][utf8 bytes] identical to a manual encoding
            [ "ä".repeat(60), "ä".repeat(300) ].forEach(function(s) {
                var utf8 = protobuf.util.utf8;
                var byteLen = utf8.length(s);
                var ref = new Ctor().uint32(byteLen).finish();
                var buf = new Ctor().string(s).finish();
                test.same(toArray(buf).slice(0, ref.length), toArray(ref), name + " length prefix matches for " + s.length + " units");
                test.equal(buf.length, ref.length + byteLen, name + " total length matches for " + s.length + " units");
                test.equal(Reader.create(buf).string(), s, name + " roundtrips for " + s.length + " units");
            });
            test.end();
        });

        test.test(name + " - growth across many fields", function(test) {
            var w = new Ctor();
            var n = 5000;
            for (var i = 0; i < n; ++i)
                w.uint32(i);
            var reader = Reader.create(w.finish());
            var ok = true;
            for (var j = 0; j < n; ++j)
                if (reader.uint32() !== j) { ok = false; break; }
            test.ok(ok, name + " all " + n + " varints survive repeated growth");
            test.equal(reader.pos, reader.len, name + " fully consumed");
            test.end();
        });
    });

    test.test("nested message roundtrip exceeding 128 bytes at multiple levels", function(test) {
        var root = protobuf.Root.fromJSON({
            nested: {
                Inner: { fields: { data: { type: "bytes", id: 1 } } },
                Outer: { fields: { inner: { type: "Inner", id: 1 }, tail: { type: "bytes", id: 2 } } }
            }
        });
        var Outer = root.lookupType("Outer");
        var big = new Uint8Array(300), tail = new Uint8Array(200);
        for (var i = 0; i < 300; ++i) big[i] = (i * 5) & 255;
        for (var j = 0; j < 200; ++j) tail[j] = (j * 9) & 255;
        var dec = Outer.decode(Outer.encode({ inner: { data: big }, tail: tail }).finish());
        test.same(toArray(dec.inner.data), toArray(big), "nested bytes intact");
        test.same(toArray(dec.tail), toArray(tail), "tail bytes intact");
        test.end();
    });

    test.end();
});