node-osc 11.1.1 → 11.2.0

package/test/test-osc-internal.mjs

@@ -1,5 +1,5 @@
 import { test } from 'tap';
-import { toBuffer, fromBuffer } from '#osc';
+import { encode, decode } from '../lib/osc.mjs';
 
 test('osc: timetag encoding with non-number value', (t) => {
   // Test the else branch in writeTimeTag that writes zeros for non-number values
@@ -15,8 +15,8 @@ test('osc: timetag encoding with non-number value', (t) => {
     ]
   };
   
-  const buffer = toBuffer(bundle);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
   
   t.equal(decoded.oscType, 'bundle', 'should decode as bundle');
   t.equal(decoded.timetag, 0, 'should decode timetag as 0 for immediate execution');
@@ -37,8 +37,8 @@ test('osc: timetag with immediate execution values', (t) => {
     ]
   };
   
-  const buffer = toBuffer(bundle);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
   
   t.equal(decoded.timetag, 0, 'should handle immediate execution timetag');
   t.end();
@@ -58,7 +58,7 @@ test('osc: argument encoding with unknown type', (t) => {
   };
   
   t.throws(() => {
-    toBuffer(message);
+    encode(message);
   }, /Unknown argument type: unknown/, 'should throw error for unknown argument type');
   t.end();
 });
@@ -76,8 +76,8 @@ test('osc: argument encoding with boolean false', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value, false, 'should encode and decode false boolean');
   t.end();
@@ -94,7 +94,7 @@ test('osc: argument encoding with unsupported object', (t) => {
   };
   
   t.throws(() => {
-    toBuffer(message);
+    encode(message);
   }, /Don't know how to encode argument/, 'should throw error for unsupported object');
   t.end();
 });
@@ -108,7 +108,7 @@ test('osc: argument encoding with undefined value', (t) => {
   };
   
   t.throws(() => {
-    toBuffer(message);
+    encode(message);
   }, /Don't know how to encode argument/, 'should throw error for undefined argument');
   t.end();
 });
@@ -121,7 +121,7 @@ test('osc: argument decoding with unknown type tag', (t) => {
   const buffer = Buffer.from(addressPart + typeTagPart);
   
   t.throws(() => {
-    fromBuffer(buffer);
+    decode(buffer);
   }, /I don't understand the argument code X/, 'should throw error for unknown type tag');
   t.end();
 });
@@ -134,7 +134,7 @@ test('osc: null argument encoding and decoding', (t) => {
   const typeTagPart = ',N\0\0'; // N is null type tag
   const buffer = Buffer.from(addressPart + typeTagPart);
   
-  const decoded = fromBuffer(buffer);
+  const decoded = decode(buffer);
   t.equal(decoded.args[0].value, null, 'should decode null argument');
   t.end();
 });
@@ -152,8 +152,8 @@ test('osc: double type argument encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Math.abs(decoded.args[0].value - 3.14159) < 0.001, 'should encode double as float');
   t.end();
@@ -168,8 +168,8 @@ test('osc: blob argument with Buffer', (t) => {
     args: [testBuffer] // Direct Buffer without type wrapper
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Buffer.isBuffer(decoded.args[0].value), 'should decode as Buffer');
   t.equal(decoded.args[0].value.toString(), 'test data', 'should preserve blob content');
@@ -184,8 +184,8 @@ test('osc: float number encoding', (t) => {
     args: [3.14159] // Non-integer number should be encoded as float
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(typeof decoded.args[0].value === 'number', 'should decode as number');
   t.ok(!Number.isInteger(decoded.args[0].value), 'should be float, not integer');
@@ -206,8 +206,8 @@ test('osc: explicit integer type encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value, 42, 'should encode and decode integer');
   t.end();
@@ -226,8 +226,8 @@ test('osc: explicit float type encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Math.abs(decoded.args[0].value - 3.14) < 0.001, 'should encode and decode float');
   t.end();
@@ -246,8 +246,8 @@ test('osc: explicit string type encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value, 'hello', 'should encode and decode string');
   t.end();
@@ -267,8 +267,8 @@ test('osc: explicit blob type encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Buffer.isBuffer(decoded.args[0].value), 'should decode as Buffer');
   t.equal(decoded.args[0].value.toString(), 'blob data', 'should preserve blob data');
@@ -288,8 +288,8 @@ test('osc: explicit boolean true type encoding', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value, true, 'should encode and decode boolean true');
   t.end();
@@ -309,8 +309,8 @@ test('osc: MIDI type encoding with Buffer', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Buffer.isBuffer(decoded.args[0].value), 'should decode as Buffer');
   t.equal(decoded.args[0].value.length, 4, 'should be 4 bytes');
@@ -339,8 +339,8 @@ test('osc: MIDI type encoding with object', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.ok(Buffer.isBuffer(decoded.args[0].value), 'should decode as Buffer');
   t.equal(decoded.args[0].value[0], 2, 'port should match');
@@ -364,7 +364,7 @@ test('osc: MIDI type with invalid buffer length', (t) => {
   };
   
   t.throws(() => {
-    toBuffer(message);
+    encode(message);
   }, /MIDI message must be exactly 4 bytes/, 'should throw error for wrong buffer length');
   t.end();
 });
@@ -383,7 +383,7 @@ test('osc: MIDI type with invalid value type', (t) => {
   };
   
   t.throws(() => {
-    toBuffer(message);
+    encode(message);
   }, /MIDI value must be a 4-byte Buffer or object/, 'should throw error for invalid value type');
   t.end();
 });
@@ -405,8 +405,8 @@ test('osc: MIDI type with partial object', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value[0], 0, 'port should default to 0');
   t.equal(decoded.args[0].value[1], 0x90, 'status should match');
@@ -434,7 +434,7 @@ test('osc: MIDI type decoding with insufficient buffer data', (t) => {
   const malformedBuffer = Buffer.concat([address, typeTags, insufficientMidiData]);
   
   t.throws(() => {
-    fromBuffer(malformedBuffer);
+    decode(malformedBuffer);
   }, /Not enough bytes for MIDI message/, 'should throw error when MIDI data is truncated');
   t.end();
 });
@@ -456,8 +456,8 @@ test('osc: MIDI type with falsy status and data1 values', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value[0], 5, 'port should match');
   t.equal(decoded.args[0].value[1], 0, 'status should default to 0');
@@ -484,8 +484,8 @@ test('osc: MIDI type with explicit zero status and data1 values', (t) => {
     ]
   };
   
-  const buffer = toBuffer(message);
-  const decoded = fromBuffer(buffer);
+  const buffer = encode(message);
+  const decoded = decode(buffer);
   
   t.equal(decoded.args[0].value[0], 3, 'port should match');
   t.equal(decoded.args[0].value[1], 0, 'status should be 0');
@@ -493,4 +493,362 @@ test('osc: MIDI type with explicit zero status and data1 values', (t) => {
   t.equal(decoded.args[0].value[3], 0x60, 'data2 should match');
   t.end();
 
-});
+});
+test('osc: timetag encoding with numeric value and fractions', (t) => {
+  // Test writeTimeTag with actual numeric timetag (lines 70-74)
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 1234567890.5, // Numeric value with fractional part
+    elements: [
+      {
+        oscType: 'message',
+        address: '/test',
+        args: []
+      }
+    ]
+  };
+  
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.oscType, 'bundle', 'should decode as bundle');
+  t.ok(Math.abs(decoded.timetag - 1234567890.5) < 0.01, 'should preserve numeric timetag with fractions');
+  t.end();
+});
+
+test('osc: timetag decoding with actual timestamp', (t) => {
+  // Test readTimeTag with non-zero, non-immediate values (lines 92-96)
+  // We encode a bundle with a real timestamp, then decode it
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 1609459200.25, // A real timestamp: 2021-01-01 00:00:00.25
+    elements: [
+      {
+        oscType: 'message',
+        address: '/timestamp',
+        args: [{ type: 'i', value: 123 }]
+      }
+    ]
+  };
+  
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.oscType, 'bundle', 'should decode as bundle');
+  t.ok(decoded.timetag > 0, 'timetag should be positive');
+  t.ok(Math.abs(decoded.timetag - 1609459200.25) < 0.01, 'should preserve timestamp value');
+  t.end();
+});
+
+test('osc: inferred integer encoding from raw number', (t) => {
+  // Test line 167: encoding raw integer without type wrapper
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [42] // Raw integer, not wrapped
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 42, 'should encode and decode raw integer');
+  t.end();
+});
+
+test('osc: inferred float encoding from raw number', (t) => {
+  // Test line 169: encoding raw float without type wrapper
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [3.14159] // Raw float, not wrapped
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.ok(Math.abs(decoded.args[0].value - 3.14159) < 0.001, 'should encode and decode raw float');
+  t.end();
+});
+
+test('osc: inferred string encoding from raw string', (t) => {
+  // Test line 172: encoding raw string without type wrapper
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: ['hello world'] // Raw string, not wrapped
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'hello world', 'should encode and decode raw string');
+  t.end();
+});
+
+test('osc: inferred boolean true encoding from raw boolean', (t) => {
+  // Test line 174 (true branch): encoding raw boolean true
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [true] // Raw boolean true, not wrapped
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, true, 'should encode and decode raw boolean true');
+  t.end();
+});
+
+test('osc: inferred boolean false encoding from raw boolean', (t) => {
+  // Test line 174 (false branch): encoding raw boolean false
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [false] // Raw boolean false, not wrapped
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, false, 'should encode and decode raw boolean false');
+  t.end();
+});
+
+test('osc: bundle with only message elements (no nested bundles)', (t) => {
+  // Test line 252: encoding message elements in bundle (else branch)
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 0,
+    elements: [
+      {
+        oscType: 'message',
+        address: '/msg1',
+        args: [{ type: 'i', value: 1 }]
+      },
+      {
+        oscType: 'message',
+        address: '/msg2',
+        args: [{ type: 'i', value: 2 }]
+      }
+    ]
+  };
+  
+  const buffer = encode(bundle);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.oscType, 'bundle', 'should decode as bundle');
+  t.equal(decoded.elements.length, 2, 'should have 2 elements');
+  t.equal(decoded.elements[0].oscType, 'message', 'first element should be message');
+  t.equal(decoded.elements[1].oscType, 'message', 'second element should be message');
+  t.end();
+});
+
+test('osc: malformed packet with missing comma in type tags', (t) => {
+  // Test lines 292-293: decoding malformed packet without comma in type tags
+  const addressBuf = Buffer.from('/test\0\0\0', 'utf8');
+  const malformedTypeTagsBuf = Buffer.from('iXX\0', 'utf8'); // Missing leading comma
+  const buffer = Buffer.concat([addressBuf, malformedTypeTagsBuf]);
+  
+  t.throws(() => {
+    decode(buffer);
+  }, /Malformed Packet/, 'should throw on malformed type tags');
+  t.end();
+});
+
+test('osc: bundle with nested bundle element', (t) => {
+  // Test line 252: encoding bundle elements in bundle (if branch)
+  const innerBundle = {
+    oscType: 'bundle',
+    timetag: 0,
+    elements: [
+      {
+        oscType: 'message',
+        address: '/inner',
+        args: [{ type: 'i', value: 99 }]
+      }
+    ]
+  };
+  
+  const outerBundle = {
+    oscType: 'bundle',
+    timetag: 0,
+    elements: [
+      {
+        oscType: 'message',
+        address: '/outer',
+        args: [{ type: 's', value: 'test' }]
+      },
+      innerBundle
+    ]
+  };
+  
+  const buffer = encode(outerBundle);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.oscType, 'bundle', 'should decode as bundle');
+  t.equal(decoded.elements.length, 2, 'should have 2 elements');
+  t.equal(decoded.elements[0].oscType, 'message', 'first element should be message');
+  t.equal(decoded.elements[1].oscType, 'bundle', 'second element should be bundle');
+  t.equal(decoded.elements[1].elements[0].address, '/inner', 'nested bundle should have correct message');
+  t.end();
+});
+
+test('osc: explicit integer type name', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'integer', value: 999 }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 999);
+  t.end();
+});
+
+test('osc: explicit float type name', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'float', value: 1.414 }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.ok(Math.abs(decoded.args[0].value - 1.414) < 0.001);
+  t.end();
+});
+
+test('osc: explicit string type name', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'test string' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'test string');
+  t.end();
+});
+
+test('osc: explicit blob type name', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'blob', value: Buffer.from([0xAA, 0xBB]) }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.ok(Buffer.isBuffer(decoded.args[0].value));
+  t.same(decoded.args[0].value, Buffer.from([0xAA, 0xBB]));
+  t.end();
+});
+
+test('osc: explicit double type name', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'double', value: 2.718281828 }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.ok(Math.abs(decoded.args[0].value - 2.718281828) < 0.001);
+  t.end();
+});
+
+test('osc: blob padding when length is multiple of 4', (t) => {
+  // Test writeBlob line 52: padding === 4 branch (should use 0)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'b', value: Buffer.from([1, 2, 3, 4]) }] // length 4
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.same(decoded.args[0].value, Buffer.from([1, 2, 3, 4]));
+  t.end();
+});
+
+test('osc: blob padding when length is not multiple of 4', (t) => {
+  // Test writeBlob line 52: padding !== 4 branch (should use padding value)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'b', value: Buffer.from([1, 2, 3]) }] // length 3
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.same(decoded.args[0].value, Buffer.from([1, 2, 3]));
+  t.end();
+});
+
+test('osc: boolean type true value', (t) => {
+  // Test boolean case ternary: true branch
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'boolean', value: true }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, true);
+  t.end();
+});
+
+test('osc: boolean type false value', (t) => {
+  // Test boolean case ternary: false branch
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'boolean', value: false }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, false);
+  t.end();
+});
+
+test('osc: explicit T type', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'T', value: true }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, true);
+  t.end();
+});
+
+test('osc: explicit F type', (t) => {
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'F', value: false }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, false);
+  t.end();
+});