// failWhen() is the function being tested. U(typeof unknownVariable) returns true, which
// causes failWhen() to pass an error object to SystemLogger. I'm passing SystemLogger.Use()
// a custom error handler function, within which we can use expect() to example the error
// object which failWhen sent using SystemLogger.EpicFail().

  describe('failWhen(), a fail-fast method',function(){
    it('Properly detect, handle, and throw reference errors',function(){

      SystemLogger.Use(function(){
        throw new ReferenceError()
      })

      expect(function(){
        failWhen( U(typeof whatever) )
      }).to.throwError(function(e){
        expect( e ).to.be.a(ReferenceError)
        expect( e ).to.not.be.a(SyntaxError)
      })


      expect(function(){
        failWhen( U(typeof undefined) )
      }).to.throwError()


      expect(function(){
        failWhen( U('undefined') )
      }).to.throwError()
    })


    it('Invokes the predefined error handler',function(done){
      var msg = 'Send this out, expect() to get it back.'

      function customErrorHandler (err) {
        console.log('\nLevel: '+err.lvl, '\n'+err.stack)
        expect( err ).to.be.a( ReferenceError )
        expect( err.message ).to.be( msg )

        done()
      }

      SystemLogger.Use(customErrorHandler)
      expect( failWhen( U(typeof whatever), msg) ).to.be( false )
    })

    var msg = 'Send this out, expect() to get it back.'


    /**
     *
     */
    it('Throws whatever error object it is given',function(done){
      SystemLogger.Use(function (err) {
        expect( err ).to.be.a( ReferenceError )
        expect( err.lvl ).to.be( 1 )
        go2()
      })
      expect( failWhen( U(typeof whatever), msg, 1, ReferenceError) ).to.be( false )

      function go2(){
        SystemLogger.Use(function (err) {
          expect( err ).to.be.a( SyntaxError )
          expect( err.lvl ).to.be( 1 )
          go3()
        })
        expect( failWhen( U(typeof whatever), msg, 1, SyntaxError) ).to.be( false )
      }

      function go3(){
        SystemLogger.Use(function (err) {
          expect( err ).to.be.a( EvalError )
          expect( err.lvl ).to.be( 1 )
          go4()
        })
        expect( failWhen( U(typeof whatever), msg, 1, EvalError) ).to.be( false )
      }
      function go4(){
        SystemLogger.Use(function (err) {
          expect( err ).to.be.a( RangeError )
          expect( err.lvl ).to.be( 1 )
          go5()
        })
        expect( failWhen( U(typeof whatever), msg, 1, RangeError) ).to.be( false )
      }
      function go5(){
        SystemLogger.Use(function (err) {
          expect( err ).to.be.a( TypeError )
          expect( err.lvl ).to.be( 1 )
          go6()
        })
        expect( failWhen( U(typeof whatever), msg, 1, TypeError) ).to.be( false )
      }
      function go6(){
        SystemLogger.Use(function (err) {
          expect( err ).to.be.a( URIError )
          expect( err.lvl ).to.be( 1 )
          done()
        })
        expect( failWhen( U(typeof whatever), msg, 1, URIError) ).to.be( false )
      }
    })
  })