buninu-linux 0.13.56 → 0.14.57

package/test/dhcp-start.test.js

@@ -0,0 +1,67 @@
+import {test,expect} from 'bun:test';
+import {createDhcpLauncher} from '../initramfs/lib/dhcp-start.js';
+const pause=ms=>Bun.sleep(ms);
+function fakeChild(){
+ let resolve,reject,stdout;
+ const exited=new Promise((yes,no)=>{resolve=yes;reject=no;});
+ return {exited,resolve,reject,kills:[],kill(signal){this.kills.push(signal);},
+ stdout:new ReadableStream({start(c){stdout=c;}}),stderr:null,
+ output(line){stdout.enqueue(Buffer.from(line));},end(){stdout.close();}};
+}
+test('launch returns immediately, isolates spawn failures and reuses running children',async()=>{
+ const calls=[],logs=[],children=[];
+ const launch=createDhcpLauncher({spawn(args){calls.push(args);if(args.at(-1)==='bad')throw new Error('spawn denied');const child=fakeChild();children.push(child);return child;},log:s=>logs.push(s),watchdogMs:500});
+ expect(launch(['bad','eth0','eth1'])).toEqual(['eth0','eth1']);
+ expect(launch(['eth0','eth1'])).toEqual([]);expect(calls.length).toBe(3);
+ expect(calls[2]).toContain('--no-dns');expect(calls[2]).toContain('--metric');
+ expect(logs.some(s=>s.includes('spawn denied'))).toBe(true);
+ for(const child of children){child.end();child.resolve(1);}await pause(5);
+ expect(logs.some(s=>s.includes('(exit 1); other interfaces are unaffected'))).toBe(true);
+ expect(launch(['eth0'])).toEqual(['eth0']);children.at(-1).end();children.at(-1).resolve(0);
+});
+test('watchdog terminates hung acquisition and escalates if SIGTERM does not exit',async()=>{
+ const child=fakeChild(),logs=[];
+ const launch=createDhcpLauncher({spawn:()=>child,log:s=>logs.push(s),watchdogMs:10,killGraceMs:10});
+ launch(['eth0']);await pause(60);
+ expect(child.kills).toEqual(['SIGTERM','SIGKILL']);child.end();child.resolve(137);await pause(5);
+ expect(logs.some(s=>s.includes('timed out; other interfaces are unaffected'))).toBe(true);
+});
+test('successful one-shot exits and clears the watchdog',async()=>{
+ const child=fakeChild();const launch=createDhcpLauncher({spawn:()=>child,log:()=>{},watchdogMs:20,killGraceMs:5});
+ launch(['eth0']);child.output('dhclient: bound to 10.0.2.15/24, lease 86400s\n');child.end();child.resolve(0);await pause(50);
+ expect(child.kills).toEqual([]);
+});
+test('stream rejection, exit rejection, kill failure and throwing logger cannot escape',async()=>{
+ const child=fakeChild(),logs=[];
+ child.stderr=new ReadableStream({start(c){c.error(null);}});
+ child.kill=()=>{throw null;};
+ const launch=createDhcpLauncher({spawn:()=>child,log:s=>logs.push(s),watchdogMs:5,killGraceMs:5});
+ expect(()=>launch(['eth0'])).not.toThrow();await pause(30);child.end();child.reject(null);await pause(5);
+ expect(logs.some(s=>s.startsWith('[dhcp eth0] failed: timed out'))).toBe(true);
+ const bad=createDhcpLauncher({spawn(){throw null;},log(){throw new Error('console failed');}});
+ expect(()=>bad(['eth0'])).not.toThrow();expect(()=>bad(null)).not.toThrow();
+});
+
+test('usb0 success and late eth0 failure each produce one correctly attributed result',async()=>{
+ const children={eth0:fakeChild(),usb0:fakeChild()},logs=[];let stderr;
+ children.eth0.stderr=new ReadableStream({start(c){stderr=c;}});
+ const launch=createDhcpLauncher({spawn:args=>children[args.at(-1)],log:s=>logs.push(s),watchdogMs:500});
+ launch(['eth0','usb0']);
+ children.usb0.output('dhclient: bound to 192.168.42.2/24, lease 3600s\n');children.usb0.end();children.usb0.resolve(0);
+ await pause(5);
+ children.eth0.resolve(1);children.eth0.end();
+ // Exit notification precedes delivery of the error; the final result must wait.
+ await pause(5);stderr.enqueue(Buffer.from('dhclient: no DHCP lease received before timeout\n'));stderr.close();await pause(10);
+ expect(logs.filter(s=>s.includes('configured '))).toEqual(['[dhcp usb0] configured 192.168.42.2/24; command finished']);
+ expect(logs.filter(s=>s.includes('failed:'))).toEqual(['[dhcp eth0] failed: no DHCP lease received before timeout (exit 1); other interfaces are unaffected']);
+ expect(logs.some(s=>s.includes('usb0')&&s.includes('failed'))).toBe(false);
+});
+
+test('unterminated output cannot hold the result open or prevent later invocations',async()=>{
+ const children=[],logs=[];
+ const launch=createDhcpLauncher({spawn(){const c=fakeChild();children.push(c);return c;},log:s=>logs.push(s),watchdogMs:500,outputGraceMs:10});
+ launch(['usb0']);children[0].output('dhclient: bound to 192.168.42.2/24, lease 3600s\n');children[0].resolve(0);
+ await pause(30);
+ expect(logs.some(s=>s.includes('configured 192.168.42.2/24'))).toBe(true);
+ expect(launch(['usb0'])).toEqual(['usb0']);children[1].end();children[1].resolve(0);
+});

package/test/dhcp.test.js

@@ -0,0 +1,99 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,readFileSync,writeFileSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {TYPE,encode,decode,leaseFrom,wrapIPv4,unwrapIPv4,checksum,DhcpClient,NakError} from '../initramfs/lib/dhcp.js';
+import {parseDhclient,Configuration,manageLease} from '../initramfs/lib/dhclient.js';
+const mac=Buffer.from('020000000001','hex');
+function reply(request,type,{ip='10.20.0.10',server=[10,20,0,1],duration=120}={}){
+ const b=Buffer.from(request.subarray(0,240));b[0]=2;Buffer.from(ip.split('.').map(Number)).copy(b,16);
+ const lease=Buffer.alloc(4);lease.writeUInt32BE(duration);
+ return Buffer.concat([b,Buffer.from([53,1,type,54,4,...server,1,4,255,255,255,0,51,4]),lease,Buffer.from([3,4,...server,6,4,1,1,1,1,255])]);
+}
+test('DHCP CLI validates options before opening sockets',()=>{
+ expect(parseDhclient(['-4','-d','-1','-v','-timeout','8','--no-dns','-H','buninu','eth0'])).toMatchObject({interface:'eth0',once:true,timeout:8,dns:false});
+ expect(parseDhclient(['usb0']).interface).toBe('usb0');
+ expect(parseDhclient(['--metric','120','usb0']).metric).toBe(120);
+ for(const args of [['--metric','32767','eth0'],[],['-6','eth0'],['-timeout','NaN','eth0'],['-r','-1','eth0'],['eth0','eth1'],['../bad']])expect(()=>parseDhclient(args)).toThrow();
+});
+test('codec validates xid, MAC, truncation, options, mask and lease timers',()=>{
+ const req=encode({type:TYPE.DISCOVER,xid:123,mac}),ack=reply(req,TYPE.ACK);
+ expect(req.length).toBeGreaterThanOrEqual(300);expect(req.readUInt16BE(10)).toBe(0x8000);
+ const parsed=decode(ack,{xid:123,mac});expect(parsed.type).toBe(TYPE.ACK);
+ expect(decode(ack,{xid:456,mac})).toBeNull();expect(decode(ack,{mac:Buffer.alloc(6)})).toBeNull();
+ expect(decode(ack.subarray(0,ack.length-3))).toBeNull();
+ expect(leaseFrom(parsed,null,1000)).toMatchObject({prefix:24,renewAt:61000,rebindAt:106000,expiresAt:121000});
+ expect(()=>leaseFrom({...parsed,mask:'255.0.255.0'},null,0)).toThrow();
+ expect(leaseFrom({...parsed,t1:200,t2:100},null,0).renewAt).toBe(60000);
+});
+test('packet transport checks header checksum, fragmentation, ports and UDP checksum',()=>{
+ const payload=reply(encode({type:1,xid:1,mac}),5);
+ const packet=wrapIPv4(payload,'10.20.0.1');packet.writeUInt16BE(67,20);packet.writeUInt16BE(68,22);
+ expect(unwrapIPv4(packet)).toEqual(payload);
+ const bad=Buffer.from(packet);bad[12]^=1;expect(unwrapIPv4(bad)).toBeNull();
+ const fragment=Buffer.from(packet);fragment.writeUInt16BE(0x2000,6);fragment.writeUInt16BE(0,10);fragment.writeUInt16BE(checksum(fragment.subarray(0,20)),10);expect(unwrapIPv4(fragment)).toBeNull();
+ packet.writeUInt16BE(123,26);expect(unwrapIPv4(packet)).toBeNull();
+});
+test('DORA retries, ignores unrelated replies, then renews and releases via unicast',async()=>{
+ let time=0,discover=0;const queue=[],sent=[];
+ const transport={send(b,server){sent.push({b,server});const t=b[242];
+   if(t===1&&++discover===1)return;
+   if(t===1){const wrong=reply(b,2);wrong.writeUInt32BE(999,4);queue.push(wrong,reply(b,2));}
+   if(t===3)queue.push(reply(b,5));
+ },receive(){return queue.shift();}};
+ const client=new DhcpClient({transport,mac,timeout:10,now:()=>time,sleep:async ms=>{time+=ms;},random:()=>.5});
+ const lease=await client.acquire();expect(lease.address).toBe('10.20.0.10');expect(discover).toBe(2);
+ time=lease.renewAt;const renewed=await client.renew(lease);expect(renewed.address).toBe(lease.address);
+ const renew=sent.at(-1);expect(renew.server).toBe('10.20.0.1');expect(renew.b.subarray(12,16)).toEqual(Buffer.from([10,20,0,10]));
+ expect(renew.b.readUInt16BE(10)).toBe(0);
+ client.release(renewed);expect(sent.at(-1).b[242]).toBe(7);expect(sent.at(-1).server).toBe(lease.server);
+});
+test('acquisition times out and NAK is surfaced during renewal',async()=>{
+ let time=0;const queue=[];
+ const client=new DhcpClient({transport:{send(){},receive:()=>queue.shift()},mac,timeout:.05,now:()=>time,sleep:async ms=>{time+=ms;}});
+ expect(await client.acquire()).toBeNull();
+ client.transport.send=b=>queue.push(reply(b,6));
+ await expect(client.renew({address:'10.20.0.10',server:'10.20.0.1',rebindAt:1000})).rejects.toBeInstanceOf(NakError);
+});
+test('configuration uses existing ip commands, preserves DNS across renewal and restores it',async()=>{
+ const dir=mkdtempSync(`${tmpdir()}/dhcp-test-`),path=`${dir}/resolv.conf`,calls=[];
+ try {
+  writeFileSync(path,'nameserver 9.9.9.9\n');
+  const config=new Configuration({interface:'eth0',dns:true,resolv:path,metric:100},async args=>calls.push(args));
+  const lease={address:'10.20.0.10',prefix:24,routers:['10.20.0.1'],dns:['1.1.1.1']};
+  await config.apply(lease);const renewed={...lease,dns:['8.8.8.8']};await config.apply(renewed,lease);
+  expect(calls[0]).toEqual(['addr','replace','10.20.0.10/24','brd','+','dev','eth0']);
+  expect(readFileSync(path,'utf8')).toContain('8.8.8.8');await config.clear(renewed);
+  expect(calls).toContainEqual(['route','replace','default','via','10.20.0.1','dev','eth0','metric','100']);
+  expect(calls).toContainEqual(['route','del','default','via','10.20.0.1','dev','eth0','metric','100']);
+  expect(readFileSync(path,'utf8')).toBe('nameserver 9.9.9.9\n');
+  await config.apply(lease);writeFileSync(path,'external edit\n');await config.clear(lease);expect(readFileSync(path,'utf8')).toBe('external edit\n');
+ }finally{rmSync(dir,{recursive:true,force:true});}
+});
+test('default invocation configures once and returns without starting renewal',async()=>{
+ const events=[],lease={address:'10.20.0.10',prefix:24,seconds:60};
+ const client={async acquire(){events.push('acquire');return lease;},renew(){throw new Error('must not renew');},release(){events.push('release');}};
+ await manageLease(client,{async apply(){events.push('apply');},async clear(){events.push('clear');}},{log:()=>{}});
+ expect(events).toEqual(['acquire','apply']);
+ expect(parseDhclient(['usb0']).once).toBe(true);
+});
+test('one-shot keeps a successful lease but cleans up failed configuration',async()=>{
+ const events=[],client={async acquire(){return {address:'10.0.0.2',prefix:24,seconds:60};},release(){events.push('release');}};
+ const config={async apply(){},async clear(){events.push('clear');}};
+ await manageLease(client,config,{once:true,log:()=>{}});expect(events).toEqual([]);
+ config.apply=async()=>{throw new Error('route failed');};
+ await expect(manageLease(client,config,{once:true,log:()=>{}})).rejects.toThrow('route failed');expect(events).toEqual(['release','clear']);
+});
+
+test('runtime libc sendto delivers a UDP datagram on loopback',async()=>{
+ const {libc,ptr,check}=await import('../initramfs/lib/dlopen.js');
+ let received;
+ const server=await Bun.udpSocket({hostname:'127.0.0.1',port:0,socket:{data(_socket,data){received=Buffer.from(data);}}});
+ const fd=check('socket',libc.symbols.socket(2,2,17));
+ try{
+  const target=Buffer.alloc(16);target.writeUInt16LE(2);target.writeUInt16BE(server.port,2);target.set([127,0,0,1],4);
+  const data=Buffer.from('dhcp transport libc probe');
+  expect(check('sendto',Number(libc.symbols.sendto(fd,ptr(data),data.length,0,ptr(target),16)))).toBe(data.length);
+  for(let i=0;i<100&&!received;i++)await Bun.sleep(5);
+  expect(received).toEqual(data);
+ }finally{libc.symbols.close(fd);server.close();}
+});

package/test/fetch-npm.test.js

@@ -23,7 +23,7 @@ const url = `http://127.0.0.1:${server.port}/archive`;
 
 test("five exact registry pins share an architecture-independent cache", () => {
   expect(npmPackages.map(({ name, version }) => `${name}@${version}`)).toEqual([
-    "buninu-browser@0.2.3", "buninu-land@0.1.3", "@drxiaozhi/casty@1.3.7",
+    "buninu-browser@0.2.4", "buninu-land@0.1.4", "@drxiaozhi/casty@1.3.7",
     "@drxiaozhi/jspulse@0.2.1", "@drxiaozhi/jspinyin@0.1.1",
   ]);
   expect(basename(npmDownloadsDir)).toBe("npm");

package/test/libc.test.js

@@ -0,0 +1,41 @@
+import {test,expect} from 'bun:test';
+import {libc,libcPath,errno,strerror,SysError,withInetSocket} from '../initramfs/lib/dlopen.js';
+import {spawnSync} from 'node:child_process';
+test('host libc loads automatically and exposes the platform errno',()=>{
+ expect(libc.symbols.close(-1)).toBe(-1);expect(libcPath.length).toBeGreaterThan(0);expect(errno()).toBe(9);expect(strerror(9)).toContain('descriptor');expect(new SysError('close').errno).toBe(9);
+ if(process.platform==='android')expect(libcPath).toBe('libc.so');
+});
+test('an explicit invalid libc path fails instead of silently falling back',()=>{
+ const r=spawnSync(process.execPath,['-e',`const {libc}=await import(${JSON.stringify(new URL('../initramfs/lib/dlopen.js',import.meta.url).href)});libc.symbols.close(-1)`],{env:{...process.env,BUNINU_LIBC:'/nonexistent/buninu-libc.so'},encoding:'utf8'});
+ expect(r.status).not.toBe(0);expect(r.stderr).toContain('/nonexistent/buninu-libc.so');
+});
+
+test('existing libc socket/ioctl helper still queries loopback without sysfs',()=>{
+ const request=Buffer.alloc(40);request.write('lo');
+ withInetSocket(ioctl=>ioctl(0x8933,request,'SIOCGIFINDEX'));
+ expect(request.readInt32LE(16)).toBeGreaterThan(0);
+});
+
+test('manual library resolves only requested symbols and keeps working after a missing symbol',()=>{
+ const moduleURL=new URL('../initramfs/lib/dlopen.js',import.meta.url).href;
+ const script=`
+ import {mock} from 'bun:test';
+ const ffi=await import('bun:ffi');
+ const calls=[];
+ mock.module('bun:ffi',()=>({...ffi,dlopen(path,symbols){
+   if(path!=='/manual/partial.so')throw new Error('unexpected fallback');
+   const name=Object.keys(symbols)[0];calls.push(name);
+   if(name!=='close')throw new Error('missing '+name);
+   return {symbols:{close:()=>7},close(){}};
+ }}));
+ const {libc}=await import(${JSON.stringify(moduleURL)});
+ if(calls.length)throw new Error('eager symbol resolution');
+ if(libc.symbols.close(0)!==7)throw new Error('supported symbol failed');
+ try {libc.symbols.mount;throw new Error('missing symbol accepted');}
+ catch(e){if(!e.message.includes('missing mount'))throw e;}
+ if(libc.symbols.close(0)!==7)throw new Error('missing symbol poisoned library');
+ if(calls.filter(x=>x==='close').length!==1)throw new Error('symbol not cached');
+ `;
+ const r=spawnSync(process.execPath,['-e',script],{env:{...process.env,BUNINU_LIBC:'/manual/partial.so'},encoding:'utf8'});
+ expect(r.stderr).toBe('');expect(r.status).toBe(0);
+});

package/test/ping.test.js

@@ -0,0 +1,80 @@
+import {test,expect} from 'bun:test';
+import {spawnSync} from 'node:child_process';
+import {resolve} from 'node:path';
+import {parsePing,checksum,echoPacket,isEchoReply} from '../initramfs/lib/ping.js';
+const command=resolve(import.meta.dir,'../initramfs/bin/ping');
+const system=Bun.which('ping');
+const separatePing6=Bun.which('ping6');
+const supports6=system&&spawnSync(system,['-6','-c','1','-W','1','::1'],{encoding:'utf8',timeout:2000}).status===0;
+const run=(args,reference=false)=>{
+ const usePing6=reference&&args.includes('-6')&&!supports6&&separatePing6;
+ const executable=reference?(usePing6?separatePing6:system):process.execPath;
+ const options=reference?args.filter(a=>a!=='-4'&&(!usePing6||a!=='-6')):[command,...args];
+ return spawnSync(executable,options,{encoding:'utf8',timeout:6000,env:{...process.env,LC_ALL:'C'}});
+};
+const summary=s=>{const m=/(\d+) packets transmitted, (\d+) (?:packets )?received,.*?(\d+)% packet loss/.exec(s);return m?m.slice(1).map(Number):null};
+const probe=system?run(['-4','-c','1','-W','1','127.0.0.1'],true):null;
+const available=probe?.status===0;
+
+test('ping parses common flags and rejects malformed arguments',()=>{
+ expect(parsePing(['-4nqD','-c3','-i','.2','-W','1','-w','5','-s','17','-t64','-I','lo','localhost'])).toMatchObject({family:4,count:3,interval:.2,timeout:1,deadline:5,size:17,ttl:64,source:'lo',host:'localhost',quiet:true,timestamp:true});
+ expect(parsePing(['localhost']).count).toBe(4);
+ expect(parsePing(['-6','--','::1']).family).toBe(6);
+ for(const args of [[],['-c'],['-c','0','localhost'],['-c','Infinity','localhost'],['-W','NaN','localhost'],['-s','65508','localhost'],['-s','-1','localhost'],['-t','256','localhost'],['-i','0','localhost'],['-w','0','localhost'],['-Z','localhost'],['a','b']])expect(()=>parsePing(args)).toThrow();
+ expect(parsePing(['--help']).help).toBe(true);
+ expect(run(['-c','0','127.0.0.1']).status).toBe(2);
+});
+
+test('ICMP checksum, reply identity, data integrity and raw IPv4 header validation',()=>{
+ for(const size of [0,1,17,56]){
+  const request=echoPacket(4,123,7,size);expect(checksum(request)).toBe(0);
+  const reply=Buffer.from(request);reply[0]=0;reply.writeUInt16BE(0,2);reply.writeUInt16BE(checksum(reply),2);
+  const info={family:4,raw:false,id:123,seq:7,packet:request};
+  expect(isEchoReply(reply,info)).toBe(true);expect(isEchoReply(request,info)).toBe(false);
+  expect(isEchoReply(reply,{...info,id:124})).toBe(false);expect(isEchoReply(reply,{...info,seq:8})).toBe(false);
+  const ip=Buffer.alloc(24);ip[0]=0x46;ip[9]=1;
+  expect(isEchoReply(Buffer.concat([ip,reply]),{...info,raw:true})).toBe(true);
+  expect(isEchoReply(reply.subarray(0,7),info)).toBe(false);
+  if(size){reply[8]^=1;expect(isEchoReply(reply,info)).toBe(false);}
+ }
+ const packet=echoPacket(6,3,4,8),reply=Buffer.from(packet);reply[0]=129;
+ expect(isEchoReply(reply,{family:6,raw:false,id:3,seq:4,packet})).toBe(true);
+});
+
+for(const size of [0,17,56,1400])test.skipIf(!available)(`system ping comparison: IPv4 count, payload ${size}, statistics and exit status`,()=>{
+ const args=['-4','-n','-c','3','-i','0.2','-W','1','-s',String(size),'127.0.0.1'];
+ const reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);
+ expect(summary(actual.stdout)).toEqual(summary(reference.stdout));expect(summary(actual.stdout)).toEqual([3,3,0]);
+ expect(actual.stdout).toContain(`${size+8} bytes from 127.0.0.1`);expect(actual.stdout).toContain('icmp_seq=3');
+ expect(actual.stdout).toMatch(/rtt min\/avg\/max\/mdev = [\d.]+\/[\d.]+\/[\d.]+\/[\d.]+ ms/);
+});
+
+test.skipIf(!available)('system ping comparison: hostname, source address, quiet mode and TTL',()=>{
+ const args=['-4','-n','-q','-c','2','-i','.2','-W','1','-t','32','-I','127.0.0.1','localhost'];
+ const reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);expect(summary(actual.stdout)).toEqual(summary(reference.stdout));expect(actual.stdout).not.toContain('icmp_seq=');
+});
+const ipv6=available&&run(['-6','-c','1','-W','1','::1'],true).status===0;
+test.skipIf(!ipv6)('system ping comparison: IPv6 loopback',()=>{
+ const args=['-6','-n','-c','3','-i','.2','-W','1','::1'],reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);expect(summary(actual.stdout)).toEqual([3,3,0]);expect(summary(actual.stdout)).toEqual(summary(reference.stdout));
+});
+test.skipIf(!available)('system ping comparison: deadline before requested count returns failure',()=>{
+ const args=['-4','-q','-c','100','-i','.2','-w','1','127.0.0.1'],reference=run(args,true),begin=performance.now(),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(1);expect(performance.now()-begin).toBeLessThan(2500);expect(summary(actual.stdout)[0]).toBeLessThan(100);
+});
+test.skipIf(!available)('Ctrl-C prints statistics and releases the socket',async()=>{
+ const child=Bun.spawn([process.execPath,command,'-i','.2','127.0.0.1'],{stdout:'pipe',stderr:'pipe'});
+ const reader=child.stdout.getReader();let output='';
+ try{
+  for(;;){const {value,done}=await reader.read();if(done)break;output+=new TextDecoder().decode(value);if(output.includes('icmp_seq=')){child.kill('SIGINT');break;}}
+  for(;;){const {value,done}=await reader.read();if(done)break;output+=new TextDecoder().decode(value);}
+  expect(await child.exited).toBe(0);expect(output).toContain('ping statistics');expect(summary(output)[1]).toBeGreaterThan(0);
+ }finally{child.kill();reader.releaseLock();}
+},6000);
+
+test.skipIf(!available)('sub-200ms interval and fractional timeout are supported independently of old Android ping',()=>{
+ const r=run(['-c','3','-i','.01','-W','.1','-D','127.0.0.1']);
+ expect(r.status).toBe(0);expect(summary(r.stdout)).toEqual([3,3,0]);expect(r.stdout).toMatch(/\[\d+\.\d+\] 64 bytes/);
+});