333

schangxiang@126.com

2025-09-19 18966e02fb573c7e2bb0c6426ed792b38b910940

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
var assert = require('assert')
var Reader = require('../')
describe('packet-reader', function() {
  beforeEach(function() {
    this.reader = new Reader(1)
  })
 
  it('reads perfect 1 length buffer', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 1, 1]))
    var result = this.reader.read()
    assert.equal(result.length, 1)
    assert.equal(result[0], 1)
    assert.strictEqual(false, this.reader.read())
  })
 
  it('reads perfect longer buffer', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 4, 1, 2, 3, 4]))
    var result = this.reader.read()
    assert.equal(result.length, 4)
    assert.strictEqual(false, this.reader.read())
  })
 
  it('reads two parts', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 1]))
    var result = this.reader.read()
    assert.strictEqual(false, result)
    this.reader.addChunk(Buffer.from([2]))
    var result = this.reader.read()
    assert.equal(result.length, 1, 'should return 1 length buffer')
    assert.equal(result[0], 2)
    assert.strictEqual(this.reader.read(), false)
  })
 
  it('reads multi-part', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 16]))
    assert.equal(false, this.reader.read())
    this.reader.addChunk(Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]))
    assert.equal(false, this.reader.read())
    this.reader.addChunk(Buffer.from([9, 10, 11, 12, 13, 14, 15, 16]))
    var result = this.reader.read()
    assert.equal(result.length, 16)
  })
 
  it('resets internal buffer at end of packet', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 16]))
    this.reader.addChunk(Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]))
    this.reader.addChunk(Buffer.from([9, 10, 11, 12, 13, 14, 15, 16]))
    var result = this.reader.read()
    assert.equal(result.length, 16)
 
    var newChunk = Buffer.from([0, 0, 0, 0, 16])
    this.reader.addChunk(newChunk)
    assert.equal(this.reader.offset, 0, 'should have been reset to 0.')
    assert.strictEqual(this.reader.chunk, newChunk)
  })
 
  it('reads multiple messages from single chunk', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 2, 1, 2]))
    var result = this.reader.read()
    assert.equal(result.length, 1, 'should have 1 length buffer')
    assert.equal(result[0], 1)
    var result = this.reader.read()
    assert.equal(result.length, 2, 'should have 2 length buffer but was ' + result.length)
    assert.equal(result[0], 1)
    assert.equal(result[1], 2)
    assert.strictEqual(false, this.reader.read())
  })
 
  it('reads 1 and a split', function() {
    this.reader.addChunk(Buffer.from([0, 0, 0, 0, 1, 1, 0, 0]))//, 0, 0, 2, 1, 2]))
    var result = this.reader.read()
    assert.equal(result.length, 1, 'should have 1 length buffer')
    assert.equal(result[0], 1)
    var result = this.reader.read()
    assert.strictEqual(result, false)
 
    this.reader.addChunk(Buffer.from([0, 0, 2, 1, 2]))
    var result = this.reader.read()
    assert.equal(result.length, 2, 'should have 2 length buffer but was ' + result.length)
    assert.equal(result[0], 1)
    assert.equal(result[1], 2)
    assert.strictEqual(false, this.reader.read())
  })
})
 
describe('variable length header', function() {
  beforeEach(function() {
    this.reader = new Reader()
  })
 
  it('reads double message buffers', function() {
    this.reader.addChunk(Buffer.from([
                                0, 0, 0, 1, 1,
                                0, 0, 0, 2, 1, 2]))
    var result = this.reader.read()
    assert(result)
    assert.equal(result.length, 1)
    assert.equal(result[0], 1)
    result = this.reader.read()
    assert(result)
    assert.equal(result.length, 2)
    assert.equal(result[0], 1)
    assert.equal(result[1], 2)
    assert.strictEqual(this.reader.read(), false)
  })
})
 
describe('1 length code', function() {
  beforeEach(function() {
    this.reader = new Reader(1)
  })
 
  it('reads code', function() {
    this.reader.addChunk(Buffer.from([9, 0, 0, 0, 1, 1]))
    var result = this.reader.read()
    assert(result)
    assert.equal(this.reader.header, 9)
    assert.equal(result.length, 1)
    assert.equal(result[0], 1)
  })
 
  it('is set on uncompleted read', function() {
    assert.equal(this.reader.header, null)
    this.reader.addChunk(Buffer.from([2, 0, 0, 0, 1]))
    assert.strictEqual(this.reader.read(), false)
    assert.equal(this.reader.header, 2)
  })
})
 
describe('postgres style packet', function() {
  beforeEach(function() {
    this.reader = new Reader({
      headerSize: 1,
      lengthPadding: -4
    })
  })
 
  it('reads with padded length', function() {
    this.reader.addChunk(Buffer.from([1, 0, 0, 0, 8, 0, 0, 2, 0]))
    var result = this.reader.read()
    assert(result)
    assert.equal(result.length, 4)
    assert.equal(result[0], 0)
    assert.equal(result[1], 0)
    assert.equal(result[2], 2)
    assert.equal(result[3], 0)
  })
})