node-osc 11.2.0 → 11.2.2

package/test/test-encode-decode.mjs

@@ -293,6 +293,102 @@ test('decode: error on malformed type tags (no leading comma)', (t) => {
   t.end();
 });
 
+test('decode: error on truncated blob data', (t) => {
+  const addressBuf = Buffer.from('/b\0\0', 'ascii');
+  const typeTagsBuf = Buffer.from(',b\0\0', 'ascii');
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeInt32BE(4, 0);
+  const dataBuf = Buffer.from([0x01, 0x02]);
+  const buffer = Buffer.concat([addressBuf, typeTagsBuf, lengthBuf, dataBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for blob/, 'should throw when blob data is truncated');
+
+  t.end();
+});
+
+test('decode: error on missing blob padding', (t) => {
+  const addressBuf = Buffer.from('/b\0\0', 'ascii');
+  const typeTagsBuf = Buffer.from(',b\0\0', 'ascii');
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeInt32BE(3, 0);
+  const dataBuf = Buffer.from([0x01, 0x02, 0x03]);
+  const buffer = Buffer.concat([addressBuf, typeTagsBuf, lengthBuf, dataBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for blob padding/, 'should throw when blob padding is missing');
+
+  t.end();
+});
+
+test('decode: error on truncated float32', (t) => {
+  const addressBuf = Buffer.from('/f\0\0', 'ascii');
+  const typeTagsBuf = Buffer.from(',f\0\0', 'ascii');
+  const dataBuf = Buffer.from([0x3f, 0x80, 0x00]);
+  const buffer = Buffer.concat([addressBuf, typeTagsBuf, dataBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for float32/, 'should throw when float32 data is truncated');
+
+  t.end();
+});
+
+test('decode: error on truncated int32', (t) => {
+  const addressBuf = Buffer.from('/i\0\0', 'ascii');
+  const typeTagsBuf = Buffer.from(',i\0\0', 'ascii');
+  const dataBuf = Buffer.from([0x00, 0x01]);
+  const buffer = Buffer.concat([addressBuf, typeTagsBuf, dataBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for int32/, 'should throw when int32 data is truncated');
+
+  t.end();
+});
+
+test('decode: error on negative blob length', (t) => {
+  const addressBuf = Buffer.from('/b\0\0', 'ascii');
+  const typeTagsBuf = Buffer.from(',b\0\0', 'ascii');
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeInt32BE(-1, 0);
+  const buffer = Buffer.concat([addressBuf, typeTagsBuf, lengthBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Invalid blob length/, 'should throw when blob length is negative');
+
+  t.end();
+});
+
+test('decode: error on bundle element size overflow', (t) => {
+  const bundleHeader = Buffer.from('#bundle\0', 'ascii');
+  const timetag = Buffer.alloc(8);
+  const sizeBuf = Buffer.alloc(4);
+  sizeBuf.writeInt32BE(0, 0);
+  const buffer = Buffer.concat([bundleHeader, timetag, sizeBuf]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet/, 'should throw when bundle element size is invalid');
+
+  t.end();
+});
+
+test('decode: error on truncated bundle timetag', (t) => {
+  const bundleHeader = Buffer.from('#bundle\0', 'ascii');
+  const timetag = Buffer.alloc(4);
+  const buffer = Buffer.concat([bundleHeader, timetag]);
+
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet: Not enough bytes for timetag/, 'should throw when timetag is truncated');
+
+  t.end();
+});
+
 test('encode and decode: nested bundle with message and bundle elements', (t) => {
   // Test the else branch in encodeBundleToBuffer for message elements
   const innerBundle = new Bundle(['/inner/message', 123]);
@@ -845,3 +941,362 @@ test('encode and decode: type "boolean" with false value', (t) => {
   t.equal(decoded.args[0].value, false);
   t.end();
 });
+
+// Tests for UTF-8 string padding to 4-byte boundaries
+// The padString function ensures OSC strings are padded based on byte length
+// (not character count) to handle multi-byte UTF-8 correctly
+
+test('encode and decode: UTF-8 string padding - ASCII 1 char', (t) => {
+  // 1 byte + 1 null terminator = 2 bytes, needs 2 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a', 'should correctly encode and decode single ASCII character');
+  
+  // Verify the string is properly padded in the buffer
+  // Address "/test" is 5 bytes + 1 null = 6 bytes, padded to 8 bytes
+  // Type tag ",s" is 2 bytes + 1 null = 3 bytes, padded to 4 bytes
+  // String "a" is 1 byte + 1 null = 2 bytes, padded to 4 bytes
+  const expectedMinLength = 8 + 4 + 4; // 16 bytes minimum
+  t.ok(buffer.length >= expectedMinLength, 'buffer should contain properly padded string');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 2 chars', (t) => {
+  // 2 bytes + 1 null = 3 bytes, needs 1 padding byte to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'ab' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'ab', 'should correctly encode and decode 2-byte string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 3 chars', (t) => {
+  // 3 bytes + 1 null terminator = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abc' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abc', 'should correctly encode and decode 3-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 5 chars', (t) => {
+  // 5 bytes + 1 null terminator = 6 bytes, needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'hello' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'hello', 'should correctly encode and decode 5-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 6 chars', (t) => {
+  // 6 bytes + 1 null = 7 bytes, needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abcdef' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abcdef', 'should correctly encode and decode 6-byte string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 7 chars', (t) => {
+  // 7 bytes + 1 null terminator = 8 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'testing' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'testing', 'should correctly encode and decode 7-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - empty string', (t) => {
+  // 0 bytes + 1 null terminator = 1 byte, needs 3 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '', 'should correctly encode and decode empty string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - emoji character', (t) => {
+  // Emoji '😀' is 4 bytes in UTF-8 + 1 null = 5 bytes, needs 3 padding to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '😀' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '😀', 'should correctly encode and decode emoji character');
+  
+  // Verify byte length calculation is correct
+  const emojiByteLength = Buffer.byteLength('😀');
+  t.equal(emojiByteLength, 4, 'emoji should be 4 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Japanese character', (t) => {
+  // Japanese 'あ' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'あ' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'あ', 'should correctly encode and decode Japanese character');
+  
+  const japaneseByteLength = Buffer.byteLength('あ');
+  t.equal(japaneseByteLength, 3, 'Japanese character should be 3 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Chinese character', (t) => {
+  // Chinese '中' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '中' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '中', 'should correctly encode and decode Chinese character');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - mixed ASCII and emoji', (t) => {
+  // 'a' (1 byte) + '😀' (4 bytes) + 'b' (1 byte) = 6 bytes + 1 null = 7 bytes
+  // needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a😀b' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a😀b', 'should correctly encode and decode mixed ASCII and emoji');
+  
+  const mixedByteLength = Buffer.byteLength('a😀b');
+  t.equal(mixedByteLength, 6, 'mixed string should be 6 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Japanese string', (t) => {
+  // 'こんにちは' (Hello in Japanese) - 5 characters, each 3 bytes = 15 bytes
+  // 15 bytes + 1 null = 16 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'こんにちは' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'こんにちは', 'should correctly encode and decode Japanese string');
+  
+  const japaneseStringByteLength = Buffer.byteLength('こんにちは');
+  t.equal(japaneseStringByteLength, 15, 'Japanese string should be 15 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - accented characters', (t) => {
+  // 'café' - 4 characters but 'é' is 2 bytes in UTF-8
+  // 'c' (1) + 'a' (1) + 'f' (1) + 'é' (2) = 5 bytes + 1 null = 6 bytes
+  // needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'café' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'café', 'should correctly encode and decode accented string');
+  
+  const accentedByteLength = Buffer.byteLength('café');
+  t.equal(accentedByteLength, 5, 'café should be 5 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - multiple strings', (t) => {
+  // Test multiple strings with different byte lengths in one message
+  const message = {
+    oscType: 'message',
+    address: '/multi',
+    args: [
+      { type: 'string', value: 'a' },      // 1 byte + null
+      { type: 'string', value: '😀' },     // 4 bytes + null
+      { type: 'string', value: 'abc' },    // 3 bytes + null
+      { type: 'string', value: '' }        // 0 bytes + null
+    ]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args.length, 4, 'should have 4 arguments');
+  t.equal(decoded.args[0].value, 'a', 'first string should be correct');
+  t.equal(decoded.args[1].value, '😀', 'second string should be correct');
+  t.equal(decoded.args[2].value, 'abc', 'third string should be correct');
+  t.equal(decoded.args[3].value, '', 'fourth string should be correct');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - address with emoji', (t) => {
+  // OSC addresses can also contain UTF-8 characters and must be properly padded
+  const message = {
+    oscType: 'message',
+    address: '/test/😀',
+    args: [{ type: 'string', value: 'data' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.address, '/test/😀', 'should correctly encode and decode address with emoji');
+  t.equal(decoded.args[0].value, 'data', 'should correctly encode and decode argument');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - long mixed string', (t) => {
+  // Test a longer string with mixed content
+  const longString = 'Hello 世界 🌍! Testing UTF-8 encoding with café and naïve.';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: longString }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, longString, 'should correctly encode and decode long mixed UTF-8 string');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - special characters', (t) => {
+  // Test various special characters that may have different byte lengths
+  const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: specialChars }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, specialChars, 'should correctly encode and decode special ASCII characters');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - control characters', (t) => {
+  // Test control characters
+  const controlChars = 'line1\nline2\ttab';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: controlChars }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, controlChars, 'should correctly encode and decode strings with newlines and tabs');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - surrogate pairs', (t) => {
+  // Test various emoji that are 4-byte UTF-8 sequences
+  const emojis = '🎉🎊🎈🎁';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: emojis }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, emojis, 'should correctly encode and decode multiple 4-byte emoji');
+  
+  const emojisByteLength = Buffer.byteLength(emojis);
+  t.equal(emojisByteLength, 16, 'four 4-byte emoji should total 16 bytes');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - zero-width characters', (t) => {
+  // Test zero-width joiner and other special Unicode characters
+  const zwj = 'a\u200Db'; // zero-width joiner
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: zwj }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, zwj, 'should correctly encode and decode strings with zero-width characters');
+  t.end();
+});

package/test/test-error-handling.mjs

@@ -1,13 +1,12 @@
-import { beforeEach, test } from 'tap';
-import { bootstrap } from './util.mjs';
+import { once } from 'node:events';
+import { test } from 'tap';
 
 import { Server, Client } from 'node-osc';
 
-beforeEach(bootstrap);
-
-test('server: socket error event is emitted', (t) => {
+test('server: socket error event is emitted', async (t) => {
   t.plan(1);
-  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const oscServer = new Server(0, '127.0.0.1');
+  await once(oscServer, 'listening');
   
   oscServer.on('error', (err) => {
     t.ok(err, 'error event should be emitted');
@@ -18,9 +17,10 @@ test('server: socket error event is emitted', (t) => {
   oscServer._sock.emit('error', new Error('test socket error'));
 });
 
-test('server: error listener can be added before listening', (t) => {
+test('server: error listener can be added before listening', async (t) => {
   t.plan(2);
-  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const oscServer = new Server(0, '127.0.0.1');
+  await once(oscServer, 'listening');
   
   oscServer.on('error', (err) => {
     t.ok(err, 'error event should be emitted');
@@ -37,7 +37,7 @@ test('server: error listener can be added before listening', (t) => {
 
 test('client: socket error event is emitted', (t) => {
   t.plan(1);
-  const client = new Client('127.0.0.1', t.context.port);
+  const client = new Client('127.0.0.1', 9999);
   
   client.on('error', (err) => {
     t.ok(err, 'error event should be emitted');
@@ -50,7 +50,7 @@ test('client: socket error event is emitted', (t) => {
 
 test('client: error listener can be added at construction', (t) => {
   t.plan(2);
-  const client = new Client('127.0.0.1', t.context.port);
+  const client = new Client('127.0.0.1', 9999);
   
   client.on('error', (err) => {
     t.ok(err, 'error event should be emitted');
@@ -67,16 +67,17 @@ test('client: error listener can be added at construction', (t) => {
 
 test('client: is an EventEmitter instance', (t) => {
   t.plan(1);
-  const client = new Client('127.0.0.1', t.context.port);
+  const client = new Client('127.0.0.1', 9999);
   
   t.ok(typeof client.on === 'function', 'client should have EventEmitter methods');
   
   client.close();
 });
 
-test('server: multiple error listeners can be attached', (t) => {
+test('server: multiple error listeners can be attached', async (t) => {
   t.plan(2);
-  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const oscServer = new Server(0, '127.0.0.1');
+  await once(oscServer, 'listening');
   
   oscServer.on('error', (err) => {
     t.ok(err, 'first listener should receive error');
@@ -96,7 +97,7 @@ test('server: multiple error listeners can be attached', (t) => {
 
 test('client: multiple error listeners can be attached', (t) => {
   t.plan(2);
-  const client = new Client('127.0.0.1', t.context.port);
+  const client = new Client('127.0.0.1', 9999);
   
   client.on('error', (err) => {
     t.ok(err, 'first listener should receive error');