test/simple/test-buffer.js

   1 common = require("../common");
   2 assert = common.assert
   3 assert = require("assert");
   4
   5 var Buffer = require('buffer').Buffer;
   6
   7 var b = new Buffer(1024);
   8
   9 console.log("b.length == " + b.length);
  10 assert.strictEqual(1024, b.length);
  11
  12 for (var i = 0; i < 1024; i++) {
  13   assert.ok(b[i] >= 0);
  14   b[i] = i % 256;
  15 }
  16
  17 for (var i = 0; i < 1024; i++) {
  18   assert.equal(i % 256, b[i]);
  19 }
  20
  21 var c = new Buffer(512);
  22
  23 // copy 512 bytes, from 0 to 512.
  24 var copied = b.copy(c, 0, 0, 512);
  25 console.log("copied " + copied + " bytes from b into c");
  26 assert.strictEqual(512, copied);
  27 for (var i = 0; i < c.length; i++) {
  28   print('.');
  29   assert.equal(i % 256, c[i]);
  30 }
  31 console.log("");
  32
  33 // try to copy 513 bytes, and hope we don't overrun c, which is only 512 long
  34 var copied = b.copy(c, 0, 0, 513);
  35 console.log("copied " + copied + " bytes from b into c");
  36 assert.strictEqual(512, copied);
  37 for (var i = 0; i < c.length; i++) {
  38   assert.equal(i % 256, c[i]);
  39 }
  40
  41 // copy all of c back into b, without specifying sourceEnd
  42 var copied = c.copy(b, 0, 0);
  43 console.log("copied " + copied + " bytes from c back into b");
  44 assert.strictEqual(512, copied);
  45 for (var i = 0; i < b.length; i++) {
  46   assert.equal(i % 256, b[i]);
  47 }
  48
  49 // copy 768 bytes from b into b
  50 var copied = b.copy(b, 0, 256, 1024);
  51 console.log("copied " + copied + " bytes from b into c");
  52 assert.strictEqual(768, copied);
  53 for (var i = 0; i < c.length; i++) {
  54   assert.equal(i % 256, c[i]);
  55 }
  56
  57 var caught_error = null;
  58
  59 // try to copy from before the beginning of b
  60 caught_error = null;
  61 try {
  62     var copied = b.copy(c, 0, 100, 10);
  63 } catch (err) {
  64     caught_error = err;
  65 }
  66 assert.strictEqual('sourceEnd < sourceStart', caught_error.message);
  67
  68 // try to copy to before the beginning of c
  69 caught_error = null;
  70 try {
  71     var copied = b.copy(c, -1, 0, 10);
  72 } catch (err) {
  73     caught_error = err;
  74 }
  75 assert.strictEqual('targetStart out of bounds', caught_error.message);
  76
  77 // try to copy to after the end of c
  78 caught_error = null;
  79 try {
  80     var copied = b.copy(c, 512, 0, 10);
  81 } catch (err) {
  82     caught_error = err;
  83 }
  84 assert.strictEqual('targetStart out of bounds', caught_error.message);
  85
  86 // try to copy starting before the beginning of b
  87 caught_error = null;
  88 try {
  89     var copied = b.copy(c, 0, -1, 1);
  90 } catch (err) {
  91     caught_error = err;
  92 }
  93 assert.strictEqual('sourceStart out of bounds', caught_error.message);
  94
  95 // try to copy starting after the end of b
  96 caught_error = null;
  97 try {
  98     var copied = b.copy(c, 0, 1024, 1025);
  99 } catch (err) {
 100     caught_error = err;
 101 }
 102 assert.strictEqual('sourceStart out of bounds', caught_error.message);
 103
 104 // a too-low sourceEnd will get caught by earlier checks
 105
 106 // try to copy ending after the end of b
 107 try {
 108     var copied = b.copy(c, 0, 1023, 1025);
 109 } catch (err) {
 110     caught_error = err;
 111 }
 112 assert.strictEqual('sourceEnd out of bounds', caught_error.message);
 113
 114 // try to create 0-length buffers
 115 new Buffer('');
 116 new Buffer('', 'ascii');
 117 new Buffer('', 'binary');
 118 new Buffer(0);
 119
 120 // try to write a 0-length string beyond the end of b
 121 b.write('', 1024);
 122 b.write('', 2048);
 123
 124 // try to copy 0 bytes worth of data into an empty buffer
 125 b.copy(new Buffer(0), 0, 0, 0);
 126
 127 // try to copy 0 bytes past the end of the target buffer
 128 b.copy(new Buffer(0), 1, 1, 1);
 129 b.copy(new Buffer(1), 1, 1, 1);
 130
 131 // try to copy 0 bytes from past the end of the source buffer
 132 b.copy(new Buffer(1), 0, 2048, 2048);
 133
 134 // try to toString() a 0-length slice of a buffer, both within and without the
 135 // valid buffer range
 136 assert.equal(new Buffer('abc').toString('ascii', 0, 0), '');
 137 assert.equal(new Buffer('abc').toString('ascii', -100, -100), '');
 138 assert.equal(new Buffer('abc').toString('ascii', 100, 100), '');
 139
 140 // try toString() with a object as a encoding
 141 assert.equal(new Buffer('abc').toString({toString: function () {return 'ascii';}}), 'abc');
 142
 143 // testing for smart defaults and ability to pass string values as offset
 144 var writeTest = new Buffer('abcdes');
 145 writeTest.write('n', 'ascii');
 146 writeTest.write('o', 'ascii', '1');
 147 writeTest.write('d', '2', 'ascii');
 148 writeTest.write('e', 3, 'ascii');
 149 writeTest.write('j', 'ascii', 4);
 150 assert.equal(writeTest.toString(), 'nodejs');
 151
 152 var asciiString = "hello world";
 153 var offset = 100;
 154 for (var j = 0; j < 500; j++) {
 155
 156   for (var i = 0; i < asciiString.length; i++) {
 157     b[i] = asciiString.charCodeAt(i);
 158   }
 159   var asciiSlice = b.toString('ascii', 0, asciiString.length);
 160   assert.equal(asciiString, asciiSlice);
 161
 162   var written = b.asciiWrite(asciiString, offset);
 163   assert.equal(asciiString.length, written);
 164   var asciiSlice = b.toString('ascii', offset, offset+asciiString.length);
 165   assert.equal(asciiString, asciiSlice);
 166
 167   var sliceA = b.slice(offset, offset+asciiString.length);
 168   var sliceB = b.slice(offset, offset+asciiString.length);
 169   for (var i = 0; i < asciiString.length; i++) {
 170     assert.equal(sliceA[i], sliceB[i]);
 171   }
 172
 173   // TODO utf8 slice tests
 174 }
 175
 176
 177 for (var j = 0; j < 100; j++) {
 178   var slice = b.slice(100, 150);
 179   assert.equal(50, slice.length);
 180   for (var i = 0; i < 50; i++) {
 181     assert.equal(b[100+i], slice[i]);
 182   }
 183 }
 184
 185
 186 // unpack
 187
 188 var b = new Buffer(10);
 189 b[0] = 0x00;
 190 b[1] = 0x01;
 191 b[2] = 0x03;
 192 b[3] = 0x00;
 193
 194 assert.deepEqual([0x0001], b.unpack('n', 0));
 195 assert.deepEqual([0x0001, 0x0300], b.unpack('nn', 0));
 196 assert.deepEqual([0x0103], b.unpack('n', 1));
 197 assert.deepEqual([0x0300], b.unpack('n', 2));
 198 assert.deepEqual([0x00010300], b.unpack('N', 0));
 199 assert.throws(function () {
 200   b.unpack('N', 8);
 201 });
 202
 203 b[4] = 0xDE;
 204 b[5] = 0xAD;
 205 b[6] = 0xBE;
 206 b[7] = 0xEF;
 207
 208 assert.deepEqual([0xDEADBEEF], b.unpack('N', 4));
 209
 210
 211 // Bug regression test
 212 var testValue = '\u00F6\u65E5\u672C\u8A9E'; // ö日本語
 213 var buffer = new Buffer(32);
 214 var size = buffer.utf8Write(testValue, 0);
 215 console.log('bytes written to buffer: ' + size);
 216 var slice = buffer.toString('utf8', 0, size);
 217 assert.equal(slice, testValue);
 218
 219
 220 // Test triple  slice
 221 var a = new Buffer(8);
 222 for (var i = 0; i < 8; i++) a[i] = i;
 223 var b = a.slice(4,8);
 224 assert.equal(4, b[0]);
 225 assert.equal(5, b[1]);
 226 assert.equal(6, b[2]);
 227 assert.equal(7, b[3]);
 228 var c = b.slice(2 , 4);
 229 assert.equal(6, c[0]);
 230 assert.equal(7, c[1]);
 231
 232
 233 var d = new Buffer([23, 42, 255]);
 234 assert.equal(d.length, 3);
 235 assert.equal(d[0], 23);
 236 assert.equal(d[1], 42);
 237 assert.equal(d[2], 255);
 238
 239 var e = new Buffer('über');
 240 assert.deepEqual(e, new Buffer([195, 188, 98, 101, 114]));
 241
 242 var f = new Buffer('über', 'ascii');
 243 assert.deepEqual(f, new Buffer([252, 98, 101, 114]));
 244
 245
 246 //
 247 // Test toString('base64')
 248 //
 249 assert.equal('TWFu', (new Buffer('Man')).toString('base64'));
 250 // big example
 251 quote = "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.";
 252 expected = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=";
 253 assert.equal(expected, (new Buffer(quote)).toString('base64'));
 254
 255
 256 b = new Buffer(1024);
 257 bytesWritten = b.write(expected, 0, 'base64');
 258 assert.equal(quote, b.toString('ascii', 0, quote.length));
 259 assert.equal(quote.length, bytesWritten);
 260
 261 assert.equal(new Buffer('', 'base64').toString(), '');
 262 assert.equal(new Buffer('K', 'base64').toString(), '');
 263
 264 // multiple-of-4 with padding
 265 assert.equal(new Buffer('Kg==', 'base64').toString(), '*');
 266 assert.equal(new Buffer('Kio=', 'base64').toString(), '**');
 267 assert.equal(new Buffer('Kioq', 'base64').toString(), '***');
 268 assert.equal(new Buffer('KioqKg==', 'base64').toString(), '****');
 269 assert.equal(new Buffer('KioqKio=', 'base64').toString(), '*****');
 270 assert.equal(new Buffer('KioqKioq', 'base64').toString(), '******');
 271 assert.equal(new Buffer('KioqKioqKg==', 'base64').toString(), '*******');
 272 assert.equal(new Buffer('KioqKioqKio=', 'base64').toString(), '********');
 273 assert.equal(new Buffer('KioqKioqKioq', 'base64').toString(), '*********');
 274 assert.equal(new Buffer('KioqKioqKioqKg==', 'base64').toString(), '**********');
 275 assert.equal(new Buffer('KioqKioqKioqKio=', 'base64').toString(), '***********');
 276 assert.equal(new Buffer('KioqKioqKioqKioq', 'base64').toString(), '************');
 277 assert.equal(new Buffer('KioqKioqKioqKioqKg==', 'base64').toString(), '*************');
 278 assert.equal(new Buffer('KioqKioqKioqKioqKio=', 'base64').toString(), '**************');
 279 assert.equal(new Buffer('KioqKioqKioqKioqKioq', 'base64').toString(), '***************');
 280 assert.equal(new Buffer('KioqKioqKioqKioqKioqKg==', 'base64').toString(), '****************');
 281 assert.equal(new Buffer('KioqKioqKioqKioqKioqKio=', 'base64').toString(), '*****************');
 282 assert.equal(new Buffer('KioqKioqKioqKioqKioqKioq', 'base64').toString(), '******************');
 283 assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKg==', 'base64').toString(), '*******************');
 284 assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKio=', 'base64').toString(), '********************');
 285
 286 // no padding, not a multiple of 4
 287 assert.equal(new Buffer('Kg', 'base64').toString(), '*');
 288 assert.equal(new Buffer('Kio', 'base64').toString(), '**');
 289 assert.equal(new Buffer('KioqKg', 'base64').toString(), '****');
 290 assert.equal(new Buffer('KioqKio', 'base64').toString(), '*****');
 291 assert.equal(new Buffer('KioqKioqKg', 'base64').toString(), '*******');
 292 assert.equal(new Buffer('KioqKioqKio', 'base64').toString(), '********');
 293 assert.equal(new Buffer('KioqKioqKioqKg', 'base64').toString(), '**********');
 294 assert.equal(new Buffer('KioqKioqKioqKio', 'base64').toString(), '***********');
 295 assert.equal(new Buffer('KioqKioqKioqKioqKg', 'base64').toString(), '*************');
 296 assert.equal(new Buffer('KioqKioqKioqKioqKio', 'base64').toString(), '**************');
 297 assert.equal(new Buffer('KioqKioqKioqKioqKioqKg', 'base64').toString(), '****************');
 298 assert.equal(new Buffer('KioqKioqKioqKioqKioqKio', 'base64').toString(), '*****************');
 299 assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKg', 'base64').toString(), '*******************');
 300 assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(), '********************');
 301
 302 // handle padding graciously, multiple-of-4 or not
 303 assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length, 32);
 304 assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=',  'base64').length, 32);
 305 assert.equal(new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw',   'base64').length, 32);
 306 assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==',  'base64').length, 31);
 307 assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=',   'base64').length, 31);
 308 assert.equal(new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg',    'base64').length, 31);
 309
 310 // This string encodes single '.' character in UTF-16
 311 dot = new Buffer('//4uAA==', 'base64');
 312 assert.equal(dot[0], 0xff);
 313 assert.equal(dot[1], 0xfe);
 314 assert.equal(dot[2], 0x2e);
 315 assert.equal(dot[3], 0x00);
 316 assert.equal(dot.toString('base64'), '//4uAA==');