@@ -7,7 +7,7 @@ const SlowBuffer = require('buffer').SlowBuffer;
7
7
8
8
9
9
const b = Buffer . allocUnsafe ( 1024 ) ;
10
- assert . strictEqual ( 1024 , b . length ) ;
10
+ assert . strictEqual ( b . length , 1024 ) ;
11
11
12
12
b [ 0 ] = - 1 ;
13
13
assert . strictEqual ( b [ 0 ] , 255 ) ;
@@ -21,17 +21,17 @@ for (let i = 0; i < 1024; i++) {
21
21
}
22
22
23
23
const c = Buffer . allocUnsafe ( 512 ) ;
24
- assert . strictEqual ( 512 , c . length ) ;
24
+ assert . strictEqual ( c . length , 512 ) ;
25
25
26
26
const d = Buffer . from ( [ ] ) ;
27
- assert . strictEqual ( 0 , d . length ) ;
27
+ assert . strictEqual ( d . length , 0 ) ;
28
28
29
29
// Test offset properties
30
30
{
31
31
const b = Buffer . alloc ( 128 ) ;
32
- assert . strictEqual ( 128 , b . length ) ;
33
- assert . strictEqual ( 0 , b . byteOffset ) ;
34
- assert . strictEqual ( 0 , b . offset ) ;
32
+ assert . strictEqual ( b . length , 128 ) ;
33
+ assert . strictEqual ( b . byteOffset , 0 ) ;
34
+ assert . strictEqual ( b . offset , 0 ) ;
35
35
}
36
36
37
37
// Test creating a Buffer from a Uint32Array
@@ -176,7 +176,7 @@ Buffer.alloc(1).write('', 1, 0);
176
176
177
177
{
178
178
const slice = b . slice ( 100 , 150 ) ;
179
- assert . strictEqual ( 50 , slice . length ) ;
179
+ assert . strictEqual ( slice . length , 50 ) ;
180
180
for ( let i = 0 ; i < 50 ; i ++ ) {
181
181
assert . strictEqual ( b [ 100 + i ] , slice [ i ] ) ;
182
182
}
@@ -213,13 +213,13 @@ Buffer.alloc(1).write('', 1, 0);
213
213
const a = Buffer . allocUnsafe ( 8 ) ;
214
214
for ( let i = 0 ; i < 8 ; i ++ ) a [ i ] = i ;
215
215
const b = a . slice ( 4 , 8 ) ;
216
- assert . strictEqual ( 4 , b [ 0 ] ) ;
217
- assert . strictEqual ( 5 , b [ 1 ] ) ;
218
- assert . strictEqual ( 6 , b [ 2 ] ) ;
219
- assert . strictEqual ( 7 , b [ 3 ] ) ;
216
+ assert . strictEqual ( b [ 0 ] , 4 ) ;
217
+ assert . strictEqual ( b [ 1 ] , 5 ) ;
218
+ assert . strictEqual ( b [ 2 ] , 6 ) ;
219
+ assert . strictEqual ( b [ 3 ] , 7 ) ;
220
220
const c = b . slice ( 2 , 4 ) ;
221
- assert . strictEqual ( 6 , c [ 0 ] ) ;
222
- assert . strictEqual ( 7 , c [ 1 ] ) ;
221
+ assert . strictEqual ( c [ 0 ] , 6 ) ;
222
+ assert . strictEqual ( c [ 1 ] , 7 ) ;
223
223
}
224
224
225
225
{
@@ -287,7 +287,7 @@ Buffer.alloc(1).write('', 1, 0);
287
287
//
288
288
// Test toString('base64')
289
289
//
290
- assert . strictEqual ( 'TWFu' , ( Buffer . from ( 'Man' ) ) . toString ( 'base64' ) ) ;
290
+ assert . strictEqual ( ( Buffer . from ( 'Man' ) ) . toString ( 'base64' ) , 'TWFu' ) ;
291
291
292
292
{
293
293
// test that regular and URL-safe base64 both work
@@ -487,7 +487,7 @@ assert.deepStrictEqual(Buffer.from(' YWJvcnVtLg', 'base64'),
487
487
const b = Buffer . from ( s ) ;
488
488
489
489
for ( let i = 0 ; i < l ; i ++ ) {
490
- assert . strictEqual ( 'h' . charCodeAt ( 0 ) , b [ i ] ) ;
490
+ assert . strictEqual ( b [ i ] , 'h' . charCodeAt ( 0 ) ) ;
491
491
}
492
492
493
493
const sb = b . toString ( ) ;
@@ -557,16 +557,16 @@ function buildBuffer(data) {
557
557
558
558
const x = buildBuffer ( [ 0x81 , 0xa3 , 0x66 , 0x6f , 0x6f , 0xa3 , 0x62 , 0x61 , 0x72 ] ) ;
559
559
560
- assert . strictEqual ( '<Buffer 81 a3 66 6f 6f a3 62 61 72>' , x . inspect ( ) ) ;
560
+ assert . strictEqual ( x . inspect ( ) , '<Buffer 81 a3 66 6f 6f a3 62 61 72>' ) ;
561
561
562
562
{
563
563
const z = x . slice ( 4 ) ;
564
- assert . strictEqual ( 5 , z . length ) ;
565
- assert . strictEqual ( 0x6f , z [ 0 ] ) ;
566
- assert . strictEqual ( 0xa3 , z [ 1 ] ) ;
567
- assert . strictEqual ( 0x62 , z [ 2 ] ) ;
568
- assert . strictEqual ( 0x61 , z [ 3 ] ) ;
569
- assert . strictEqual ( 0x72 , z [ 4 ] ) ;
564
+ assert . strictEqual ( z . length , 5 ) ;
565
+ assert . strictEqual ( z [ 0 ] , 0x6f ) ;
566
+ assert . strictEqual ( z [ 1 ] , 0xa3 ) ;
567
+ assert . strictEqual ( z [ 2 ] , 0x62 ) ;
568
+ assert . strictEqual ( z [ 3 ] , 0x61 ) ;
569
+ assert . strictEqual ( z [ 4 ] , 0x72 ) ;
570
570
}
571
571
572
572
{
@@ -576,27 +576,27 @@ assert.strictEqual('<Buffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
576
576
577
577
{
578
578
const z = x . slice ( 0 , 4 ) ;
579
- assert . strictEqual ( 4 , z . length ) ;
580
- assert . strictEqual ( 0x81 , z [ 0 ] ) ;
581
- assert . strictEqual ( 0xa3 , z [ 1 ] ) ;
579
+ assert . strictEqual ( z . length , 4 ) ;
580
+ assert . strictEqual ( z [ 0 ] , 0x81 ) ;
581
+ assert . strictEqual ( z [ 1 ] , 0xa3 ) ;
582
582
}
583
583
584
584
{
585
585
const z = x . slice ( 0 , 9 ) ;
586
- assert . strictEqual ( 9 , z . length ) ;
586
+ assert . strictEqual ( z . length , 9 ) ;
587
587
}
588
588
589
589
{
590
590
const z = x . slice ( 1 , 4 ) ;
591
- assert . strictEqual ( 3 , z . length ) ;
592
- assert . strictEqual ( 0xa3 , z [ 0 ] ) ;
591
+ assert . strictEqual ( z . length , 3 ) ;
592
+ assert . strictEqual ( z [ 0 ] , 0xa3 ) ;
593
593
}
594
594
595
595
{
596
596
const z = x . slice ( 2 , 4 ) ;
597
- assert . strictEqual ( 2 , z . length ) ;
598
- assert . strictEqual ( 0x66 , z [ 0 ] ) ;
599
- assert . strictEqual ( 0x6f , z [ 1 ] ) ;
597
+ assert . strictEqual ( z . length , 2 ) ;
598
+ assert . strictEqual ( z [ 0 ] , 0x66 ) ;
599
+ assert . strictEqual ( z [ 1 ] , 0x6f ) ;
600
600
}
601
601
602
602
[ 'ucs2' , 'ucs-2' , 'utf16le' , 'utf-16le' ] . forEach ( ( encoding ) => {
@@ -616,33 +616,33 @@ assert.strictEqual('<Buffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
616
616
const b = Buffer . from ( [ 0xde , 0xad , 0xbe , 0xef ] ) ;
617
617
let s = String . fromCharCode ( 0xffff ) ;
618
618
b . write ( s , 0 , 'latin1' ) ;
619
- assert . strictEqual ( 0xff , b [ 0 ] ) ;
620
- assert . strictEqual ( 0xad , b [ 1 ] ) ;
621
- assert . strictEqual ( 0xbe , b [ 2 ] ) ;
622
- assert . strictEqual ( 0xef , b [ 3 ] ) ;
619
+ assert . strictEqual ( b [ 0 ] , 0xff ) ;
620
+ assert . strictEqual ( b [ 1 ] , 0xad ) ;
621
+ assert . strictEqual ( b [ 2 ] , 0xbe ) ;
622
+ assert . strictEqual ( b [ 3 ] , 0xef ) ;
623
623
s = String . fromCharCode ( 0xaaee ) ;
624
624
b . write ( s , 0 , 'latin1' ) ;
625
- assert . strictEqual ( 0xee , b [ 0 ] ) ;
626
- assert . strictEqual ( 0xad , b [ 1 ] ) ;
627
- assert . strictEqual ( 0xbe , b [ 2 ] ) ;
628
- assert . strictEqual ( 0xef , b [ 3 ] ) ;
625
+ assert . strictEqual ( b [ 0 ] , 0xee ) ;
626
+ assert . strictEqual ( b [ 1 ] , 0xad ) ;
627
+ assert . strictEqual ( b [ 2 ] , 0xbe ) ;
628
+ assert . strictEqual ( b [ 3 ] , 0xef ) ;
629
629
}
630
630
631
631
{
632
632
// Binary encoding should write only one byte per character.
633
633
const b = Buffer . from ( [ 0xde , 0xad , 0xbe , 0xef ] ) ;
634
634
let s = String . fromCharCode ( 0xffff ) ;
635
635
b . write ( s , 0 , 'latin1' ) ;
636
- assert . strictEqual ( 0xff , b [ 0 ] ) ;
637
- assert . strictEqual ( 0xad , b [ 1 ] ) ;
638
- assert . strictEqual ( 0xbe , b [ 2 ] ) ;
639
- assert . strictEqual ( 0xef , b [ 3 ] ) ;
636
+ assert . strictEqual ( b [ 0 ] , 0xff ) ;
637
+ assert . strictEqual ( b [ 1 ] , 0xad ) ;
638
+ assert . strictEqual ( b [ 2 ] , 0xbe ) ;
639
+ assert . strictEqual ( b [ 3 ] , 0xef ) ;
640
640
s = String . fromCharCode ( 0xaaee ) ;
641
641
b . write ( s , 0 , 'latin1' ) ;
642
- assert . strictEqual ( 0xee , b [ 0 ] ) ;
643
- assert . strictEqual ( 0xad , b [ 1 ] ) ;
644
- assert . strictEqual ( 0xbe , b [ 2 ] ) ;
645
- assert . strictEqual ( 0xef , b [ 3 ] ) ;
642
+ assert . strictEqual ( b [ 0 ] , 0xee ) ;
643
+ assert . strictEqual ( b [ 1 ] , 0xad ) ;
644
+ assert . strictEqual ( b [ 2 ] , 0xbe ) ;
645
+ assert . strictEqual ( b [ 3 ] , 0xef ) ;
646
646
}
647
647
648
648
{
@@ -715,11 +715,11 @@ assert.strictEqual('<Buffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
715
715
{
716
716
// test offset returns are correct
717
717
const b = Buffer . allocUnsafe ( 16 ) ;
718
- assert . strictEqual ( 4 , b . writeUInt32LE ( 0 , 0 ) ) ;
719
- assert . strictEqual ( 6 , b . writeUInt16LE ( 0 , 4 ) ) ;
720
- assert . strictEqual ( 7 , b . writeUInt8 ( 0 , 6 ) ) ;
721
- assert . strictEqual ( 8 , b . writeInt8 ( 0 , 7 ) ) ;
722
- assert . strictEqual ( 16 , b . writeDoubleLE ( 0 , 8 ) ) ;
718
+ assert . strictEqual ( b . writeUInt32LE ( 0 , 0 ) , 4 ) ;
719
+ assert . strictEqual ( b . writeUInt16LE ( 0 , 4 ) , 6 ) ;
720
+ assert . strictEqual ( b . writeUInt8 ( 0 , 6 ) , 7 ) ;
721
+ assert . strictEqual ( b . writeInt8 ( 0 , 7 ) , 8 ) ;
722
+ assert . strictEqual ( b . writeDoubleLE ( 0 , 8 ) , 16 ) ;
723
723
}
724
724
725
725
{
0 commit comments