doLog(logger: Brolog | typeof Brolog, loggerName: string) {
   logger.error('LogApp', 'error messsage from %s', loggerName)
   logger.warn('LogApp', 'warn message from %s', loggerName)
   logger.info('LogApp', 'info message from %s', loggerName)
   logger.verbose('LogApp', 'verbose message from %s', loggerName)
   logger.silly('LogApp', 'silly message from %s', loggerName)
 }

 constructor(
   private authService: AuthService
   , private router: Router
   , private log: Brolog
 ) {
   log.verbose('AuthGuardService', 'constructor()')
 }

 beforeEach(() => {
   TestBed.configureTestingModule({
     providers: [
       {
         provide: Brolog,
         useFactory() { return Brolog.instance('info') },
       },
       Injector,
     ],
   })
 })

function doLog() {
  log.error('LogApp', 'error')
  log.warn('LogApp', 'warn')
  log.info('LogApp', 'info')
  log.verbose('LogApp', 'verbose')
  log.silly('LogApp', 'silly')
}

  public updateTimer(delayTime?: number) {
    delayTime = delayTime || this.delayTime()
    log.verbose('Talker', 'updateTimer(%s)', delayTime)

    if (this.timer) { clearTimeout(this.timer) }
    this.timer = setTimeout(this.say.bind(this), delayTime, 3)
  }

 public load() {
   const text = this.obj.text.join(', ')
   log.verbose('Talker', 'load(%s)', text)
   this.obj.text = []
   this.obj.time = []
   return text
 }

  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
    this.log.verbose('AuthGuardService', 'canActivate(%s)', state.url)
    if (this.authService.loggedIn) {
      this.log.verbose('AuthGuardService', 'canActivate() YES')
      return true
    }

    this.log.verbose('AuthGuardService', 'canActivate() NO')

    // Store the attempted URL for redirecting
    this.authService.redirectUrl = state.url

    // Navigate to the login page
    this.router.navigate(['/login'])
    return false
  }

.on('message', async m => {
  if (m.self()) { return }

  // co(function* () {
  //   const msg = yield m.load()
  const room = m.room()

  if (room && /Wechaty/i.test(await room.topic())) {
    log.info('Bot', 'talk: %s'  , m)
    talk(m)
  } else {
    log.info('Bot', 'recv: %s'  , m)
  }
  // })
  // .catch(e => log.error('Bot', 'on message rejected: %s' , e))
})

 public async say() {
   log.verbose('Talker', 'say()')
   const text  = this.load()
   await this.thinker(text)
   .then(reply => this.emit('say', reply))
   this.timer = undefined
 }

 constructor(
   thinker: (text: string) => Promise<string>,
 ) {
   log.verbose('Talker()')
   super()
   this.thinker = thinker
   this.obj = {
     text: [],
     time: [],
   }
 }