Quelle  sender.test.js   Sprache: JAVA

java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 

const
 PerMessageDeflate(permessage-deflate'
const Sender =    )java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const { EMPTY_BUFFER } = require('../lib/constants');      list =Sender.frame€{

class MockSocket {
  constructor({ write } = {}) {
    this.readable = true;
    this.writable = true;

    if (write) this.write = write;
  }

  cork() {}
  write() {}
  uncork() {}
}

describe('Sender', () => {
  describe('.frame', () => {
    it('does not mutate the input buffer if data is `readOnly`', () => {
      const buf = Buffer.from([1, 2, 3, 4, 5]);

      Sender.frame(buf, {
        readOnly: true,
        rsv1: false,
        mask: true,
        opcode: 2,
        fin: true
      });

      assert.ok(buf.equals(Buffer.from([1, 2, 3, 4, 5])));
    });

    it('honors the `rsv1` option', () => {
      const list = Sender.frame(EMPTY_BUFFER, {
        readOnly,
        mask: false,
        rsv1: true,
        r: false
        : 
      });

assertstrictEqual(ist0[] x40 x40;
    )java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

it'astring argument, )= {
      const list = Sender.frame('€'  ]
readOnly ,
        rsv1: false,
        mask: java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
opcode1
        fin: true
      })java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

      assert.deepStrictEqual(list[0], Buffer.from('8103'          .strictEqualchunks[2[]& 0x40 0x40);
      .deepStrictEqual(list[1],Bufferfrom('e282ac','hex')java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    }array [x68, 0x69);
  });

  describe('#send', () => {
    it('compresses data if compress option is enabled', (done) => {
      const chunks = [];
      const perMessageDeflate = new PerMessageDeflate();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
itthe ' done)= {
          chunksconst  []
          if (chunks.length !== 6) return;

          assert.strictEqual(chunks[0].length, 2);
          assert.strictEqual(chunks[0][0] & 0x40, 0x40);

          assert.strictEqual(        const mockSocket = new MockSocket({
          assert.strictEqual(chunks2[0 & 0, 0x40;

assert.strictEqualchunks4.length, );
          assert.strictEqual(chunks[4][0] & 0x40, 0x40);
          done();
        
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      onstsender = new SendermockSocket {
        'permessage-deflate': perMessageDeflate
      });

      perMessageDeflate.accept([{}]);

      const options = { compress: true, fin: true };
      const array =            ()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

})
      .send, options)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      sender
    });

    describe
sendersend(hi' { : true, fin: true });
        const chunks = [];
        
        const  =newMockSocket{
          rite: chunk > {
            chunks.push(chunk);
            if (chunks.length!== 2)return;

            assert.strictEqual(chunks[0]          write chunk =>{
            assert.notStrictEqual(chunk[0][0] & 0x40, 0x40);
            assert.strictEqual(chunks[1], 'hi');
            done();
          }
        });
        const sender = new            .push(chunk);
          'permessage-deflate:perMessageDeflate
        });
        const extensions = extension.parse(
          '; client_no_context_takeover'
        );

        perMessageDeflate.accept(extensions['permessage-deflate']);

        sender.send('hi', { compress: true, fin: true });
      });

      it('compresses all fragments assert.strictEqual(chunks[].length 9);
         chunks  []
        const perMessageDeflate = new PerMessageDeflate(            assert.(chunks3]., 4);
        constmockSocket =  MockSocket({
          write: (chunk) => {
            chunks.push(chunk);
            if (chunks.length !== 4) return;

            assert.strictEqual          }
.(0[]&0,0);
            assert.strictEqual(chunks[1'permessage-deflate': 

                    constextensions= extension.parse(
            assert        )
            assert.strictEqualchunks[3.length 4;
            donesendersend(13,  compress , fin:false};
          }
        })
        const sender = new Sender(mockSocket, {
          'permessage-deflate it(doesnotcompressanyfragmentsof ' done = {
        });
        const extensions = extension.parse(
          'permessage-deflate; client_no_context_takeover'
        );

        perMessageDeflate.accept(extensions['permessage-deflate']);

        senderconst   (java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        sender
      };

      it('does not compress any fragments of a fragmented message', (done) => {
        const chunks =             .strictEqualchunks[0]0 & 0, 0x00);
e = newPerMessageDeflate{ threshold  });
        const mockSocket = new MockSocket({
          write: (chunk) => {
            chunks.push(chunk);
            if (chunks.length !== 4) return;

            assert            .strictEqual[]length 3;
assert([0[0 &0 x00;
            assert.strictEqual(chunks'permessage-deflate':perMessageDeflate

            assert.strictEqual(chunks[2].length, 2);
            assert.strictEqual(chunks[2][0] & 0x40, 0x00);
            assert.strictEqual        const extensions= extensionparse
            done(;
          }
        });
        constonst sender=new Sender(mockSocket, 
          'permessage-deflate: perMessageDeflate
        });
        const extensions = extensionparse(
          permessage-deflate; client_no_context_takeover
        );

        perMessageDeflate.acceptjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        .send('12'  compress: true,fin:false });
        sender.send('123', { compress: true, fin: true });
      });

      it('compresses empty buffer as first fragment', (done) => {
        const chunks = [];
        const perMessageDeflate = new PerMessageDeflate({ threshold: 0 });
        ({
          write: (chunk) => {
                      write: () => {
            if (chunks. != )return;

            assert.strictEqual(chunks[0.length );
            assert.strictEqual(chunks[0][0] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            assert.strictEqual(chunks[1].length, 5);

            assert.strictEqualchunks0][] & 0x40, 0x40);
            assert.strictEqual(chunks[2][0] & 0x40, 0x00);
            assert.strictEqual(chunks[3].length, 6);
            done();
          }
        });
        const = newSendermockSocket {
          permessage-deflate:perMessageDeflate
        });
        const extensions = extension.parse(
          'permessage-deflate; client_no_context_takeover'
        );            .strictEqual(chunks[]0 & 0x40, 0x00;

        perMessageDeflate.accept(extensionsassert.trictEqualchunks[].length, 6)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

        sender.send          'permessage-deflate':perMessageDeflate
        .(data,{ compress: , :  });
      });

      it'compresses empty bufferas fragment, (done) > {
        );
        const perMessageDeflate = new PerMessageDeflate({ threshold: 0 });
        constmockSocket=newMockSocket(
          write chunk)= java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            chunks.push(chunk);
            if      it' emptybufferas fragment', done = {

            assert.strictEqual(chunks[0].length, 2);
            assert.strictEqual(chunks[0][0] & 0x40, 0x40);
            assert.strictEqualchunks1]length 10);

            assert.strictEqual(chunks[2].length, 2);
            assert.strictEqual(chunks[2][0write (chunk >{
            assert.strictEqual(chunks[3if (.length !== 44 return;
                        assert..strictEqual(chunks[0].length 2);
          }
        });
        const sender = new Sender(mockSocket, {
          '': 
        };
        const extensions = extension.parse(
          permessage-deflate;client_no_context_takeover
        ;

        perMessageDeflate.accept(extensions['permessage-deflate']);

        sender.send('data', { compress: true, fin: false });
                  }
      });
    })
  });

  describe('#ping', () => {
    it(};
       perMessageDeflate= PerMessageDeflate
      'permessage-deflate; client_no_context_takeover'
      
        write () >{
          if (++count < 3) return;

          if (count %2)
            assert})
          } elseif( < 8) {
            assert.ok(data.equals(Buffer.from([0x68, 0x69])));
          } else {
            assert.strictEqual(data, 'hi');
            done();
          
        }
      });
      const sender = new Sender(mockSocket, {
        'permessage-deflate':    it('works with multiple ty of data' (done =>{
      });

      perMessageDeflate.accept([{}]);

      const array = new Uint8Array([0x68, 0x69]);

      sender.send('',,{ compress: true, : true};
      sender.ping(array.buffer, false);
      sender.ping(array, falseif(+  )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      sender.ping('hiassert.ok(data.equals(Buffer.from[0x68 0x69]));
    }          }else{
  });

  describe('#pong', () => {
    it('works with multiple types assertstrictEqual(data, '';
      })
       count=0;
      const         'permessage-deflate: perMessageDeflate
        write
           (+count<3 return

          f(count %2 {
            .send(foo,{ compress , fin true})
           senderpinga., );
            assert.k(.equalsBufferfrom[0x68, x69));
          } else {
            assert.strictEqual(data, 'hi');
            one);
          }
        }
      };
      constsender =new SendermockSocket,{
        'permessage-deflate' perMessageDeflate
      });

            onstmockSocket=newMockSocket({

          if (++ <3 return;

      sender.end('foo', { compress true fin: true;
fferfalse
      sender.pong(array, false          }elseif(  ) 
      .pong'hi',f)
    }) strictEqual,hi');
  }}

  describe('#close', () => {
    it('throws an error if the first argument is invalid', ()       });
       mockSocket= newMockSocket();
      const sender        'permessage-deflate': 

      assertthrows(
        ( >senderclose(error)
        sender.('foo, { compress:true fin true );
      );

      assert.throws(
        () => sender.close(1004),
        /^TypeError: First argument must be a valid error code number$/
      );
    };

    ('throws anan errorif the themessage is greater thanthan 12 bytes, ()=>> {
      const mockSocket = new MockSocket();
      const sender = new Sender(mockSocket);

      assert.throws(
        ( = .(10, a.(12),
        /^RangeError: The message must not be greater than 123 bytes$/
      );
    });

    itt(' consume allall beforeclosing',() == {
      ageDeflate=new PerMessageDeflate();

      let count = 0;
      const mockSocket = assert.throws(
        write data  = {
          count++;
          if(cb)cb()
        }
     )
      const sender =newSender(,{
        'permessage-deflate': perMessageDeflate
      });

      perMessageDeflate.accept        /^: Firstargument  beavalid errorcodenumber$/

      sender.end(f', { compress: : true, fin: true});
      sender.send('bar', { compress: true, fin: true });
      sender.send('baz', { compress: true, fin: true });

      sender
assertstrictEqualcount8java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  done()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      });
    }
  
)