const onSourceChanged = (curr: fs.Stats, prev :fs.Stats) => {
      // console.log(process.pid, 'server changed')
      for (let filename of selfSourceFiles) {
        fs.unwatchFile(filename)
      }

      for (let filename of sourceFiles) {
        fs.unwatchFile(filename)
      }

      if (process.env.IS_SUBPROCESS) {
        process.exit(0)
        return
      }

      if (isClosing) {
        return
      }
      isClosing = true

      if (httpServer) {
        // console.log(process.pid, 'closing server', httpServer.listening)
        httpServer.close(() => {
          setTimeout(restartAsSubproc, 100)
        })
        httpServer.unref()
      } else {
        setTimeout(restartAsSubproc, 100)
      }
    }

 watchFile('testfile', {persistent: false, interval: 1000}, (curr, prev) => {
   expect(curr.size).toBe(16);
   expect(prev.size).toBe(12);
   expect(zoneASpec.onScheduleTask).toHaveBeenCalled();
   expect(Zone.current.name).toBe('A');
   unwatchFile('testfile');
   unlink('testfile', () => {
     done();
   });
 });

      .then(() => {
        unwatchFile(readyFile);

        // We have to watch for errors until the tunnel has started
        // successfully at which point we only want to watch for
        // status messages to emit
        readMessage = readStatus;

        readRunningMessage('');
        readMessage = undefined;
      })

      watchFile(readyFile, { persistent: false, interval: 1007 }, function(
        current,
        previous
      ) {
        if (Number(current.mtime) === Number(previous.mtime)) {
          // readyFile hasn't been modified, so ignore the event
          return;
        }

        unwatchFile(readyFile);
        resolve();
      });

                watchFile: (fileName, callback) => {
                    // watchFile polls a file every 250ms, picking up file notifications.
                    _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);

                    return {
                        close() { _fs.unwatchFile(fileName, fileChanged); }
                    };

                    function fileChanged(curr: any, prev: any) {
                        if (+curr.mtime <= +prev.mtime) {
                            return;
                        }

                        callback(fileName);
                    };
                },

 close: () => _fs.unwatchFile(fileName, fileChanged)

	/** Clears callbacks added with onModify(). */
	unwatch() {
		fs.unwatchFile(this.path);
	}