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