node-datachannel 0.10.0 → 0.11.0

package/src/web-socket-server-wrapper.h

@@ -16,13 +16,11 @@
 class WebSocketServerWrapper : public Napi::ObjectWrap<WebSocketServerWrapper>
 {
 public:
-  static Napi::FunctionReference constructor;
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
   WebSocketServerWrapper(const Napi::CallbackInfo &info);
   ~WebSocketServerWrapper();
 
   // Functions
-
   void stop(const Napi::CallbackInfo &info);
   Napi::Value port(const Napi::CallbackInfo &info);
 
@@ -31,13 +29,17 @@ public:
 
   // Close all existing WebSocketServers
   static void StopAll();
- 
+
 private:
-  static std::unordered_set<WebSocketServerWrapper*> instances;
-  std::unique_ptr<rtc::WebSocketServer> mWebSocketServerPtr = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnClientCallback = nullptr;
+  static Napi::FunctionReference constructor;
+  static std::unordered_set<WebSocketServerWrapper *> instances;
 
   void doStop();
+
+  std::unique_ptr<rtc::WebSocketServer> mWebSocketServerPtr = nullptr;
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnClientCallback = nullptr;
 };
 
 #endif // WEB_SOCKET_SERVER_WRAPPER_H

package/src/web-socket-wrapper.cpp

@@ -65,6 +65,9 @@ WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::Objec
         mWebSocketPtr = *(info[1].As<Napi::External<std::shared_ptr<rtc::WebSocket>>>().Data());
         PLOG_DEBUG << "Using WebSocket got from WebSocketServer";
         instances.insert(this);
+
+        // Closed callback must be set to trigger cleanup
+        mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
         return;
     }
 
@@ -82,6 +85,9 @@ WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::Objec
             return;
         }
         instances.insert(this);
+
+        // Closed callback must be set to trigger cleanup
+        mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
         return;
     }
 
@@ -240,7 +246,7 @@ WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::Objec
     PLOG_DEBUG << "WebSocket created";
 
     // Closed callback must set to trigger cleanup
-    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
 
     instances.insert(this);
 }

package/test/connectivity.js

@@ -1,30 +1,16 @@
 import nodeDataChannel from '../lib/index.js';
 
 nodeDataChannel.initLogger('Debug');
-nodeDataChannel.preload();
 
 let dc1 = null;
 let dc2 = null;
 
-// Config options
-// export interface RtcConfig {
-//     iceServers: string[];
-//     proxyServer?: ProxyServer;
-//     bindAddress?: string;
-//     enableIceTcp?: boolean;
-//     portRangeBegin?: number;
-//     portRangeEnd?: number;
-//     maxMessageSize?: number;
-//     iceTransportPolicy?: TransportPolicy;
-// }
-//
 // "iceServers" option is an array of stun/turn server urls
 // Examples;
 // STUN Server Example          : stun:stun.l.google.com:19302
 // TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
 // TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
 // TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
-
 let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
 
 // Set Callbacks
@@ -78,15 +64,7 @@ peer2.onDataChannel((dc) => {
     });
 });
 
-// DataChannel Options
-// export interface DataChannelInitConfig {
-//     protocol?: string;
-//     negotiated?: boolean;
-//     id?: number;
-//     ordered?: boolean;
-//     maxPacketLifeTime?: number;
-//     maxRetransmits?: number;
-// }
+// Create DataChannel
 dc1 = peer1.createDataChannel('test');
 dc1.onOpen(() => {
     dc1.sendMessage('Hello from Peer1');

package/test/wpt-tests/README.md

@@ -0,0 +1,46 @@
+# Setup (First time usage)
+
+> cd test/wpt-tests
+
+> npm i
+
+> git submodule update --init --recursive --depth 1
+
+> cd wpt
+
+> ./wpt make-hosts-file | sudo tee -a /etc/hosts
+
+After your hosts file is configured, the servers will be locally accessible at:
+
+http://web-platform.test:8000/
+
+https://web-platform.test:8443/ \*
+
+To use the web-based runner point your browser to:
+
+http://web-platform.test:8000/tools/runner/index.html
+
+https://web-platform.test:8443/tools/runner/index.html \*
+
+# Running Tests
+
+> npm run test
+
+OR
+
+> npm run:wpt  (Let this run)
+
+> npm run:test (In an other console)
+
+The files that tested are listed in `wpt-test-list.js`. The commented lines need still to be one-by-one tested and uncommented.
+
+Contributions are welcome!
+
+# Run a test for Chrome
+
+./wpt run chrome /webrtc/RTCPeerConnection-addIceCandidate.html
+
+# Latest Test Results
+
+Please check [last-test-results.md](./last-test-results.md) page
+

package/test/wpt-tests/chrome-failed-tests.js

@@ -0,0 +1,42 @@
+import { runWptTests } from './wpt.js';
+
+// Some tests also fail in Chrome
+// We don't also care of them
+let chromeFailedTests = [];
+let totalNumberOfTests = 0;
+
+export async function runChromeTests(wptTestList) {
+    chromeFailedTests = [];
+    totalNumberOfTests = 0;
+    let results = await runWptTests(wptTestList, true);
+    for (let i = 0; i < results.length; i++) {
+        totalNumberOfTests += results[i].result?.length || 0;
+        if (results[i].result && results[i].result.some((test) => test.status === 1)) {
+            chromeFailedTests.push({
+                test: results[i].test,
+                result: results[i].result.filter((test) => test.status === 1),
+            });
+        }
+    }
+}
+
+export function getChromeFailedTests() {
+    return chromeFailedTests;
+}
+
+export function isTestForChromeFailed(testPath, testName) {
+    return chromeFailedTests.some(
+        (test) =>
+            test.test === testPath && test.result.some((result) => result.name === testName && result.status === 1),
+    );
+}
+
+export function getTotalNumberOfTests() {
+    return totalNumberOfTests;
+}
+
+// Test
+// (async () => {
+//     await runChromeTests();
+//     console.log(getChromeFailedTests());
+// })();

package/test/wpt-tests/index.js

@@ -0,0 +1,96 @@
+import ndc from '../../lib/index.js';
+import wptTestList from './wpt-test-list.js';
+import { runWptTests } from './wpt.js';
+import { runChromeTests, isTestForChromeFailed, getTotalNumberOfTests } from './chrome-failed-tests.js';
+
+// Set the log level, for debugging purposes
+// ndc.initLogger('Debug');
+
+// Catch unhandled exceptions
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    process.exit(1);
+});
+
+// Run tests for Chrome
+console.log('# Running tests for Chrome...');
+await runChromeTests(wptTestList);
+//console.log(JSON.stringify(getChromeFailedTests(), null, 2));
+
+// Run tests for node-datachannel
+console.log('');
+console.log('# Running tests for node-datachannel...');
+let results = await runWptTests(wptTestList);
+
+// Calc total number of tests
+let totalTests = 0;
+results.forEach((result) => {
+    totalTests += result.result.length;
+});
+
+// Compare results
+// Filter failed tests for node-datachannel
+let failedTestsLibrary = [];
+results.forEach((result) => {
+    if (result.result.some((test) => test.status === 1)) {
+        failedTestsLibrary.push({
+            test: result.test,
+            result: result.result.filter((test) => test.status === 1),
+        });
+    }
+});
+let totalFailedTestsLibrary = 0;
+failedTestsLibrary.forEach((result) => {
+    totalFailedTestsLibrary += result.result.length;
+});
+// console.log(JSON.stringify(failedTestsLibrary, null, 2));
+
+// Filter out any failed tests that also failed in Chrome
+let failedTests = [];
+failedTestsLibrary.forEach((result) => {
+    if (result.result.some((test) => !isTestForChromeFailed(result.test, test.name))) {
+        failedTests.push({
+            test: result.test,
+            result: result.result.filter((test) => !isTestForChromeFailed(result.test, test.name)),
+        });
+    }
+});
+let totalFailedTests = 0;
+failedTests.forEach((result) => {
+    totalFailedTests += result.result.length;
+});
+// console.log(JSON.stringify(failedTests, null, 2));
+
+// Print Report
+// Print Test Names
+console.log('');
+console.log('# Tests Report');
+// Total number of tests
+console.log('Total Tests [Chrome]: ', getTotalNumberOfTests(), '  ');
+console.log('Total Tests [Library]: ', totalTests, ' (We expect this to be equal to Total Tests [Chrome])  ');
+// Number of passed tests
+console.log('Passed Tests: ', totalTests - totalFailedTestsLibrary, '  ');
+// Number of failed tests for chrome + node-datachannel
+console.log(
+    'Failed Tests (Chrome + Library): ',
+    totalFailedTestsLibrary - totalFailedTests,
+    " (We don't care about these tests)  ",
+);
+// Number of failed tests
+console.log('Failed Tests: ', totalFailedTests, '   ');
+
+// Print Failed Tests
+console.log('');
+console.log('## Failed Tests');
+for (let i = 0; i < failedTests.length; i++) {
+    console.log(`### ${failedTests[i].test}`);
+    for (let j = 0; j < failedTests[i].result.length; j++) {
+        console.log(`- name: ${failedTests[i].result[j].name}  `);
+        console.log(`  message: ${failedTests[i].result[j].message}  `);
+    }
+}
+
+// Sometimes failed tests are not cleaned up
+// This can prevent the process from exiting
+ndc.cleanup();
+console.log('End of tests');

package/test/wpt-tests/last-test-results.md

@@ -0,0 +1,205 @@
+
+> wpt-tests@1.0.0 run:test
+> node index.js
+
+# Running tests for Chrome...
+Running test: /webrtc/getstats.html  
+Running test: /webrtc/historical.html  
+Running test: /webrtc/no-media-call.html  
+Running test: /webrtc/promises-call.html  
+Running test: /webrtc/receiver-track-live.https.html  
+Running test: /webrtc/recvonly-transceiver-can-become-sendrecv.https.html  
+Running test: /webrtc/RollbackEvents.https.html  
+Running test: /webrtc/RTCCertificate.html  
+Running test: /webrtc/RTCConfiguration-bundlePolicy.html  
+Running test: /webrtc/RTCConfiguration-iceCandidatePoolSize.html  
+Running test: /webrtc/RTCConfiguration-iceServers.html  
+Running test: /webrtc/RTCConfiguration-iceTransportPolicy.html  
+Running test: /webrtc/RTCConfiguration-rtcpMuxPolicy.html  
+Running test: /webrtc/RTCConfiguration-validation.html  
+Running test: /webrtc/RTCDataChannel-bufferedAmount.html  
+Running test: /webrtc/RTCDataChannelEvent-constructor.html  
+Running test: /webrtc/RTCDataChannel-iceRestart.html  
+Running test: /webrtc/RTCDataChannel-id.html  
+Running test: /webrtc/RTCDataChannel-send-blob-order.html  
+Running test: /webrtc/RTCPeerConnection-addIceCandidate.html  
+Running test: /webrtc/RTCPeerConnection-addTcpIceCandidate.html  
+
+# Running tests for node-datachannel...
+Running test: /webrtc/getstats.html  
+Running test: /webrtc/historical.html  
+Running test: /webrtc/no-media-call.html  
+Running test: /webrtc/promises-call.html  
+Running test: /webrtc/receiver-track-live.https.html  
+Running test: /webrtc/recvonly-transceiver-can-become-sendrecv.https.html  
+Running test: /webrtc/RollbackEvents.https.html  
+Running test: /webrtc/RTCCertificate.html  
+Running test: /webrtc/RTCConfiguration-bundlePolicy.html  
+Running test: /webrtc/RTCConfiguration-iceCandidatePoolSize.html  
+Running test: /webrtc/RTCConfiguration-iceServers.html  
+Running test: /webrtc/RTCConfiguration-iceTransportPolicy.html  
+Running test: /webrtc/RTCConfiguration-rtcpMuxPolicy.html  
+Running test: /webrtc/RTCConfiguration-validation.html  
+Running test: /webrtc/RTCDataChannel-bufferedAmount.html  
+Running test: /webrtc/RTCDataChannelEvent-constructor.html  
+Running test: /webrtc/RTCDataChannel-iceRestart.html  
+Running test: /webrtc/RTCDataChannel-id.html  
+Running test: /webrtc/RTCDataChannel-send-blob-order.html  
+Running test: /webrtc/RTCPeerConnection-addIceCandidate.html  
+Running test: /webrtc/RTCPeerConnection-addTcpIceCandidate.html  
+
+# Tests Report
+Total Tests [Chrome]:  316   
+Total Tests [Library]:  316  (We expect this to be equal to Total Tests [Chrome])  
+Passed Tests:  228   
+Failed Tests (Chrome + Library):  35  (We don't care about these tests)  
+Failed Tests:  53    
+
+## Failed Tests
+### /webrtc/historical.html
+- name: RTCRtpTransceiver member setDirection should not exist  
+  message: RTCRtpTransceiver is not defined  
+### /webrtc/recvonly-transceiver-can-become-sendrecv.https.html
+- name: [audio] recvonly transceiver can become sendrecv  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: [video] recvonly transceiver can become sendrecv  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+### /webrtc/RTCCertificate.html
+- name: Constructing RTCPeerConnection with expired certificate should reject with InvalidAccessError  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Calling setConfiguration with different set of certs should reject with InvalidModificationError  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: RTCCertificate should have at least one fingerprint  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: RTCPeerConnection({ certificates }) should generate offer SDP with fingerprint of provided certificate  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+### /webrtc/RTCConfiguration-bundlePolicy.html
+- name: Default bundlePolicy should be balanced  
+  message: assert_equals: expected (string) "balanced" but got (undefined) undefined  
+- name: new RTCPeerConnection({ bundlePolicy: undefined }) should have bundlePolicy balanced  
+  message: assert_equals: expected (string) "balanced" but got (undefined) undefined  
+- name: new RTCPeerConnection({ bundlePolicy: null }) should throw TypeError  
+  message: assert_throws_js: function "() =>
+      new RTCPeerConnection({ bundlePolicy: null })" did not throw  
+- name: new RTCPeerConnection({ bundlePolicy: 'invalid' }) should throw TypeError  
+  message: assert_throws_js: function "() =>
+      new RTCPeerConnection({ bundlePolicy: 'invalid' })" did not throw  
+- name: setConfiguration({ bundlePolicy: 'max-compat' }) with initial bundlePolicy max-bundle should throw InvalidModificationError  
+  message: assert_throws_dom: function "() =>
+      pc.setConfiguration({ bundlePolicy: 'max-compat' })" did not throw  
+- name: setConfiguration({}) with initial bundlePolicy max-bundle should throw InvalidModificationError  
+  message: assert_throws_dom: function "() =>
+      pc.setConfiguration({})" did not throw  
+### /webrtc/RTCConfiguration-iceCandidatePoolSize.html
+- name: Initialize a new RTCPeerConnection with no iceCandidatePoolSize  
+  message: assert_equals: expected (number) 0 but got (undefined) undefined  
+- name: Initialize a new RTCPeerConnection with iceCandidatePoolSize: -1 (Out Of Range)  
+  message: assert_throws_js: function "() => {
+    new RTCPeerConnection({
+      iceCandidatePoolSize: -1
+    });
+  }" did not throw  
+- name: Initialize a new RTCPeerConnection with iceCandidatePoolSize: 256 (Out Of Range)  
+  message: assert_throws_js: function "() => {
+    new RTCPeerConnection({
+      iceCandidatePoolSize: 256
+    });
+  }" did not throw  
+- name: Reconfigure RTCPeerConnection instance iceCandidatePoolSize to -1 (Out Of Range)  
+  message: assert_throws_js: function "() => {
+    pc.setConfiguration({
+      iceCandidatePoolSize: -1
+    });
+  }" did not throw  
+- name: Reconfigure RTCPeerConnection instance iceCandidatePoolSize to 256 (Out Of Range)  
+  message: assert_throws_js: function "() => {
+    pc.setConfiguration({
+      iceCandidatePoolSize: 256
+    });
+  }" did not throw  
+### /webrtc/RTCConfiguration-iceTransportPolicy.html
+- name: new RTCPeerConnection(config) - with null iceTransportPolicy should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ iceTransportPolicy: null })" threw object "SyntaxError: Invalid ICE transport policy, expected string" ("SyntaxError") expected instance of function "function TypeError() { [native code] }" ("TypeError")  
+- name: setConfiguration(config) - with null iceTransportPolicy should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ iceTransportPolicy: null })" did not throw  
+- name: iceTransportPolicy "relay" on offerer should prevent candidate gathering  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: iceTransportPolicy "relay" on answerer should prevent candidate gathering  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Changing iceTransportPolicy from "all" to "relay" causes an ICE restart which should fail, with no new candidates  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Changing iceTransportPolicy from "relay" to "all" causes an ICE restart which should succeed  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Changing iceTransportPolicy from "all" to "relay", and back to "all" prompts an ICE restart  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Changing iceTransportPolicy from "all" to "relay" on the answerer has no effect on a subsequent offer/answer  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+### /webrtc/RTCConfiguration-rtcpMuxPolicy.html
+- name: new RTCPeerConnection() should have default rtcpMuxPolicy require  
+  message: assert_equals: expected (string) "require" but got (undefined) undefined  
+- name: new RTCPeerConnection({ rtcpMuxPolicy: undefined }) should have default rtcpMuxPolicy require  
+  message: assert_equals: expected (string) "require" but got (undefined) undefined  
+- name: new RTCPeerConnection(config) - with { rtcpMuxPolicy: null } should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ rtcpMuxPolicy: null })" did not throw  
+- name: setConfiguration(config) - with { rtcpMuxPolicy: null } should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ rtcpMuxPolicy: null })" did not throw  
+- name: new RTCPeerConnection(config) - with { rtcpMuxPolicy: 'invalid' } should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ rtcpMuxPolicy: 'invalid' })" did not throw  
+- name: setConfiguration(config) - with { rtcpMuxPolicy: 'invalid' } should throw TypeError  
+  message: assert_throws_js: function "() =>
+      makePc({ rtcpMuxPolicy: 'invalid' })" did not throw  
+- name: setConfiguration({ rtcpMuxPolicy: 'negotiate' }) with initial rtcpMuxPolicy require should throw InvalidModificationError  
+  message: assert_throws_dom: function "() =>
+      pc.setConfiguration({ rtcpMuxPolicy: 'negotiate' })" did not throw  
+- name: setConfiguration({ rtcpMuxPolicy: 'require' }) with initial rtcpMuxPolicy negotiate should throw InvalidModificationError  
+  message: assert_throws_dom: function "() =>
+      pc.setConfiguration({ rtcpMuxPolicy: 'require' })" did not throw  
+- name: setConfiguration({}) with initial rtcpMuxPolicy require should leave rtcpMuxPolicy to require  
+  message: assert_equals: expected (string) "require" but got (undefined) undefined  
+- name: setConfiguration({}) with initial rtcpMuxPolicy negotiate should throw InvalidModificationError  
+  message: assert_throws_dom: function "() =>
+      pc.setConfiguration({})" did not throw  
+- name: setRemoteDescription throws InvalidAccessError when called with an offer without rtcp-mux and rtcpMuxPolicy is set to require  
+  message: assert_unreached: Should have rejected: undefined Reached unreachable code  
+### /webrtc/RTCDataChannel-bufferedAmount.html
+- name: datachannel bufferedAmount should increase to byte length of encodedunicode string sent  
+  message: assert_equals: Expect bufferedAmount to be the byte length of the unicode string expected 12 but got 0  
+- name: datachannel bufferedAmount should increase to byte length of buffer sent  
+  message: assert_equals: Expect bufferedAmount to increase to byte length of sent buffer expected 5 but got 0  
+- name: datachannel bufferedAmount should not decrease immediately after initiating closure  
+  message: assert_equals: Expect bufferedAmount to increase to byte length of sent buffer expected 5 but got 0  
+- name: datachannel bufferedAmount should not decrease after closing the peer connection  
+  message: assert_equals: Expect bufferedAmount to increase to byte length of sent buffer expected 5 but got 0  
+### /webrtc/RTCDataChannel-iceRestart.html
+- name: Data channel remains usable after ICE restart  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+- name: Data channel remains usable at each step of an ICE restart  
+  message: promise_test: Unhandled rejection with value: object "Error: Not implemented"  
+### /webrtc/RTCDataChannel-id.html
+- name: DTLS client uses odd data channel IDs  
+  message: promise_test: Unhandled rejection with value: object "Error: libdatachannel error while adding remote description: Got the local description as remote description"  
+- name: DTLS server uses even data channel IDs  
+  message: promise_test: Unhandled rejection with value: object "Error: libdatachannel error while adding remote description: Got the local description as remote description"  
+- name: In-band negotiation with a specific ID should not work  
+  message: assert_equals: expected (object) null but got (number) 42  
+- name: Odd/even role should not be violated when mixing with negotiated channels  
+  message: assert_equals: Channel id must be null before DTLS role has been determined expected (object) null but got (number) 65535  
+### /webrtc/RTCPeerConnection-addIceCandidate.html
+- name: addIceCandidate with second sdpMid and sdpMLineIndex should add candidate to second media stream  
+  message: assert_true: Expect candidate line to be found after media line m=video expected true got false  
+- name: Adding multiple candidates should add candidates to their corresponding media stream  
+  message: assert_true: Expect candidate line to be found after media line m=video expected true got false  
+- name: Add candidate for media stream 2 with null usernameFragment should succeed  
+  message: assert_true: Expect candidate line to be found after media line m=video expected true got false  
+### /webrtc/RTCPeerConnection-addTcpIceCandidate.html
+- name: TCP candidate aimed at port 8001 accepted  
+  message: promise_test: Unhandled rejection with value: undefined  
+- name: TCP addIceCandidate aimed at port 8001 accepted  
+  message: promise_test: Unhandled rejection with value: object "OperationError: Invalid sdpMid format"  
+- name: TCP candidate aimed at Fetch bad port 119 ignored  
+  message: assert_unreached: Reached unreachable code