Update all Angular libs (run update_all.sh).

third_party/pkg/angular/test/mock/http_backend_spec.dart

 library angular.mock.http_backend_spec;
 
 import '../_specs.dart';
 
 class _Chain {
   var _thenFn;
   _Chain({then}) {
     _thenFn = then;
   }
 
   then(x) => _thenFn(x);
 }
 
-main() => describe('MockHttpBackend', () {
-  TestBed _;
-  beforeEach(inject((TestBed tb) => _ = tb));
-
-  var hb, callback, realBackendSpy;
-
-  var noop = (_, __) {};
-  var undefined = null;
-
-  beforeEach(inject((HttpBackend httpBackend) {
-    callback = jasmine.createSpy('callback');
-    hb = httpBackend;
-  }));
-
-
-  it('should respond with first matched definition', () {
-    hb.when('GET', '/url1').respond(200, 'content', {});
-    hb.when('GET', '/url1').respond(201, 'another', {});
-
-    callback.andCallFake((status, response) {
-      expect(status).toBe(200);
-      expect(response).toBe('content');
-    });
-
-    hb('GET', '/url1', null, callback);
-    expect(callback).not.toHaveBeenCalled();
-    hb.flush();
-    expect(callback).toHaveBeenCalledOnce();
-  });
-
-
-  it('should respond with JSON', inject((Logger logger) {
-    hb.when('GET', '/url1').respond(200, ['abc'], {});
-    hb.when('GET', '/url2').respond(200, {'key': 'value'}, {});
-
-
-    callback.andCallFake((status, response) {
-      expect(status).toBe(200);
-      logger(response);
-    });
-
-    hb('GET', '/url1', null, callback);
-    hb('GET', '/url2', null, callback);
-    hb.flush();
-    expect(logger).toEqual(['["abc"]', '{"key":"value"}']);
-  }));
-
-
-  it('should throw error when unexpected request', () {
-    hb.when('GET', '/url1').respond(200, 'content');
-    expect(() {
-      hb('GET', '/xxx');
-    }).toThrow('Unexpected request: GET /xxx\nNo more requests expected');
-  });
-
-
-  it('should throw an error on an exception in then', async(() {
-    hb.expectGET('/url').respond(200, 'content');
-
-    expect(() {
-      hb.request('/url', method: 'GET').then((x) {
-        throw ["exceptiona"];
-      });
-      hb.flush();
-      microLeap();
-    }).toThrow('exceptiona');
-  }));
-
-
-  it('should match headers if specified', () {
-    try {
-    hb.when('GET', '/url', null, {'X': 'val1'}).respond(201, 'content1');
-    hb.when('GET', '/url', null, {'X': 'val2'}).respond(202, 'content2');
-    hb.when('GET', '/url').respond(203, 'content3');
-
-    hb('GET', '/url', null, (status, response) {
-      expect(status).toBe(203);
-      expect(response).toBe('content3');
-    });
-
-    hb('GET', '/url', null, (status, response) {
-      expect(status).toBe(201);
-      expect(response).toBe('content1');
-    }, {'X': 'val1'});
-
-    hb('GET', '/url', null, (status, response) {
-      expect(status).toBe(202);
-      expect(response).toBe('content2');
-    }, {'X': 'val2'});
-
-    hb.flush();
-    } catch (e,s) { print("$e $s"); }
-  });
-
-
-  it('should match data if specified', () {
-    hb.when('GET', '/a/b', '{a: true}').respond(201, 'content1');
-    hb.when('GET', '/a/b').respond(202, 'content2');
-
-    hb('GET', '/a/b', '{a: true}', (status, response) {
-      expect(status).toBe(201);
-      expect(response).toBe('content1');
-    });
-
-    hb('GET', '/a/b', '{}', (status, response) {
-      expect(status).toBe(202);
-      expect(response).toBe('content2');
-    });
-
-    hb.flush();
-  });
-
-
-  it('should match only method', () {
-    hb.when('GET').respond(202, 'c');
-    callback.andCallFake((status, response) {
-      expect(status).toBe(202);
-      expect(response).toBe('c');
-    });
-
-    hb('GET', '/some', null, callback, {});
-    hb('GET', '/another', null, callback, {'X-Fake': 'Header'});
-    hb('GET', '/third', 'some-data', callback, {});
-    hb.flush();
-
-    expect(callback).toHaveBeenCalled();
-  });
-
-
-  it('should preserve the order of requests', () {
-    hb.when('GET', '/url1').respond(200, 'first');
-    hb.when('GET', '/url2').respond(201, 'second');
-
-    hb('GET', '/url2', null, callback);
-    hb('GET', '/url1', null, callback);
-
-    hb.flush();
-
-    expect(callback.callCount).toBe(2);
-    expect(callback.argsForCall[0]).toEqual([201, 'second', '']);
-    expect(callback.argsForCall[1]).toEqual([200, 'first', '']);
-  });
-
-
-  describe('respond()', () {
-    it('should take values', () {
-      hb.expect('GET', '/url1').respond(200, 'first', {'header': 'val'});
-      hb('GET', '/url1', null, callback);
-      hb.flush();
-
-      expect(callback).toHaveBeenCalledOnceWith(200, 'first', "header: val");
-    });
-
-    it('should take function', () {
-      hb.expect('GET', '/some').respond((m, u, d, h) {
-        return [301, m + u + ';' + d + ';a=' + h['a'], {'Connection': 'keep-alive'}];
-      });
-
-      hb('GET', '/some', 'data', callback, {'a': 'b'});
-      hb.flush();
-
-      expect(callback).toHaveBeenCalledOnceWith(301, 'GET/some;data;a=b', 'Connection: keep-alive');
-    });
-
-    it('should default status code to 200', () {
+void main() {
+  describe('MockHttpBackend', () {
+    TestBed _;
+    beforeEach((TestBed tb) => _ = tb);
+
+    var hb, callback, realBackendSpy;
+
+    var noop = (_, __) {};
+    var undefined = null;
+
+    beforeEach((HttpBackend httpBackend) {
+      callback = jasmine.createSpy('callback');
+      hb = httpBackend;
+    });
+
+
+    it('should respond with first matched definition', () {
+      hb.when('GET', '/url1').respond(200, 'content', {});
+      hb.when('GET', '/url1').respond(201, 'another', {});
+
       callback.andCallFake((status, response) {
         expect(status).toBe(200);
-        expect(response).toBe('some-data');
-      });
-
-      hb.expect('GET', '/url1').respond('some-data');
-      hb.expect('GET', '/url2').respond('some-data', {'X-Header': 'true'});
+        expect(response).toBe('content');
+      });
+
+      hb('GET', '/url1', null, callback);
+      expect(callback).not.toHaveBeenCalled();
+      hb.flush();
+      expect(callback).toHaveBeenCalledOnce();
+    });
+
+
+    it('should respond with JSON', (Logger logger) {
+      hb.when('GET', '/url1').respond(200, ['abc'], {});
+      hb.when('GET', '/url2').respond(200, {'key': 'value'}, {});
+
+
+      callback.andCallFake((status, response) {
+        expect(status).toBe(200);
+        logger(response);
+      });
+
       hb('GET', '/url1', null, callback);
       hb('GET', '/url2', null, callback);
       hb.flush();
+      expect(logger).toEqual(['["abc"]', '{"key":"value"}']);
+    });
+
+
+    it('should throw error when unexpected request', () {
+      hb.when('GET', '/url1').respond(200, 'content');
+      expect(() {
+        hb('GET', '/xxx');
+      }).toThrow('Unexpected request: GET /xxx\nNo more requests expected');
+    });
+
+
+    it('should throw an error on an exception in then', async(() {
+      hb.expectGET('/url').respond(200, 'content');
+
+      expect(() {
+        hb.request('/url', method: 'GET').then((x) {
+          throw ["exceptiona"];
+        });
+        hb.flush();
+        microLeap();
+      }).toThrow('exceptiona');
+    }));
+
+
+    it('should match headers if specified', () {
+      try {
+        hb.when('GET', '/url', null, {'X': 'val1'}).respond(201, 'content1');
+        hb.when('GET', '/url', null, {'X': 'val2'}).respond(202, 'content2');
+        hb.when('GET', '/url').respond(203, 'content3');
+
+        hb('GET', '/url', null, (status, response) {
+          expect(status).toBe(203);
+          expect(response).toBe('content3');
+        });
+
+        hb('GET', '/url', null, (status, response) {
+          expect(status).toBe(201);
+          expect(response).toBe('content1');
+        }, {'X': 'val1'});
+
+        hb('GET', '/url', null, (status, response) {
+          expect(status).toBe(202);
+          expect(response).toBe('content2');
+        }, {'X': 'val2'});
+
+        hb.flush();
+      } catch (e,s) { print("$e $s"); }
+    });
+
+
+    it('should match data if specified', () {
+      hb.when('GET', '/a/b', '{a: true}').respond(201, 'content1');
+      hb.when('GET', '/a/b').respond(202, 'content2');
+
+      hb('GET', '/a/b', '{a: true}', (status, response) {
+        expect(status).toBe(201);
+        expect(response).toBe('content1');
+      });
+
+      hb('GET', '/a/b', '{}', (status, response) {
+        expect(status).toBe(202);
+        expect(response).toBe('content2');
+      });
+
+      hb.flush();
+    });
+
+
+    it('should match only method', () {
+      hb.when('GET').respond(202, 'c');
+      callback.andCallFake((status, response) {
+        expect(status).toBe(202);
+        expect(response).toBe('c');
+      });
+
+      hb('GET', '/some', null, callback, {});
+      hb('GET', '/another', null, callback, {'X-Fake': 'Header'});
+      hb('GET', '/third', 'some-data', callback, {});
+      hb.flush();
+
       expect(callback).toHaveBeenCalled();
+    });
+
+
+    it('should preserve the order of requests', () {
+      hb.when('GET', '/url1').respond(200, 'first');
+      hb.when('GET', '/url2').respond(201, 'second');
+
+      hb('GET', '/url2', null, callback);
+      hb('GET', '/url1', null, callback);
+
+      hb.flush();
+
       expect(callback.callCount).toBe(2);
-    });
-
-
-    it('should default response headers to ""', () {
-      hb.expect('GET', '/url1').respond(200, 'first');
-      hb.expect('GET', '/url2').respond('second');
-
-      hb('GET', '/url1', null, callback);
-      hb('GET', '/url2', null, callback);
-
-      hb.flush();
-
-      expect(callback.callCount).toBe(2);
-      expect(callback.argsForCall[0]).toEqual([200, 'first', '']);
-      expect(callback.argsForCall[1]).toEqual([200, 'second', '']);
-    });
-  });
-
-
-  describe('expect()', () {
-    it('should require specified order', () {
-      hb.expect('GET', '/url1').respond(200, '');
-      hb.expect('GET', '/url2').respond(200, '');
-
+      expect(callback.argsForCall[0]).toEqual([201, 'second', '']);
+      expect(callback.argsForCall[1]).toEqual([200, 'first', '']);
+    });
+
+
+    describe('respond()', () {
+      it('should take values', () {
+        hb.expect('GET', '/url1').respond(200, 'first', {'header': 'val'});
+        hb('GET', '/url1', null, callback);
+        hb.flush();
+
+        expect(callback).toHaveBeenCalledOnceWith(200, 'first', "header: val");
+      });
+
+      it('should take function', () {
+        hb.expect('GET', '/some').respond((m, u, d, h) {
+          return [301, m + u + ';' + d + ';a=' + h['a'], {'Connection': 'keep-alive'}];
+        });
+
+        hb('GET', '/some', 'data', callback, {'a': 'b'});
+        hb.flush();
+
+        expect(callback).toHaveBeenCalledOnceWith(301, 'GET/some;data;a=b', 'Connection: keep-alive');
+      });
+
+      it('should default status code to 200', () {
+        callback.andCallFake((status, response) {
+          expect(status).toBe(200);
+          expect(response).toBe('some-data');
+        });
+
+        hb.expect('GET', '/url1').respond('some-data');
+        hb.expect('GET', '/url2').respond('some-data', {'X-Header': 'true'});
+        hb('GET', '/url1', null, callback);
+        hb('GET', '/url2', null, callback);
+        hb.flush();
+        expect(callback).toHaveBeenCalled();
+        expect(callback.callCount).toBe(2);
+      });
+
+
+      it('should default response headers to ""', () {
+        hb.expect('GET', '/url1').respond(200, 'first');
+        hb.expect('GET', '/url2').respond('second');
+
+        hb('GET', '/url1', null, callback);
+        hb('GET', '/url2', null, callback);
+
+        hb.flush();
+
+        expect(callback.callCount).toBe(2);
+        expect(callback.argsForCall[0]).toEqual([200, 'first', '']);
+        expect(callback.argsForCall[1]).toEqual([200, 'second', '']);
+      });
+    });
+
+
+    describe('expect()', () {
+      it('should require specified order', () {
+        hb.expect('GET', '/url1').respond(200, '');
+        hb.expect('GET', '/url2').respond(200, '');
+
+        expect(() {
+          hb('GET', '/url2', null, noop, {});
+        }).toThrow('Unexpected request: GET /url2\nExpected GET /url1');
+      });
+
+
+      it('should have precedence over when()', () {
+        callback.andCallFake((status, response) {
+          expect(status).toBe(299);
+          expect(response).toBe('expect');
+        });
+
+        hb.when('GET', '/url').respond(200, 'when');
+        hb.expect('GET', '/url').respond(299, 'expect');
+
+        hb('GET', '/url', null, callback, null);
+        hb.flush();
+        expect(callback).toHaveBeenCalledOnce();
+      });
+
+
+      it('should throw exception when only headers differs from expectation', () {
+        hb.when('GET', '/match').respond(200, '', {});
+        hb.expect('GET', '/match', null, {'Content-Type': 'application/json'}).respond(200, '', {});
+
+        expect(() {
+          hb('GET', '/match', null, noop, {});
+        }).toThrow('Expected GET /match with different headers\n' +
+        'EXPECTED: {"Content-Type":"application/json"}\nGOT:      {}');
+      });
+
+
+      it('should throw exception when only data differs from expectation', () {
+        hb.when('GET', '/match').respond(200, '', {});
+        hb.expect('GET', '/match', 'some-data').respond(200, '', {});
+
+        expect(() {
+          hb('GET', '/match', 'different', noop, null);
+        }).toThrow('Expected GET /match with different data\n' +
+        'EXPECTED: some-data\nGOT:      different');
+      });
+
+
+      it("should use when's respond() when no expect() respond is defined", () {
+        callback.andCallFake((status, response) {
+          expect(status).toBe(201);
+          expect(response).toBe('data');
+        });
+
+        hb.when('GET', '/some').respond(201, 'data');
+        hb.expect('GET', '/some');
+        hb('GET', '/some', null, callback);
+        hb.flush();
+
+        expect(callback).toHaveBeenCalled();
+        expect(() { hb.verifyNoOutstandingExpectation(); }).not.toThrow();
+      });
+    });
+
+
+    describe('flush()', () {
+      it('flush() should flush requests fired during callbacks', () {
+        hb.when('GET', '/some').respond(200, '');
+        hb.when('GET', '/other').respond(200, '');
+        hb('GET', '/some', null, (_, __) {
+          hb('GET', '/other', null, callback);
+        });
+
+        hb.flush();
+        expect(callback).toHaveBeenCalled();
+      });
+
+
+      it('should flush given number of pending requests', () {
+        hb.when('GET').respond(200, '');
+        hb('GET', '/some', null, callback);
+        hb('GET', '/some', null, callback);
+        hb('GET', '/some', null, callback);
+
+        hb.flush(2);
+        expect(callback).toHaveBeenCalled();
+        expect(callback.callCount).toBe(2);
+      });
+
+
+      it('should throw exception when flushing more requests than pending', () {
+        hb.when('GET').respond(200, '');
+        hb('GET', '/url', null, callback);
+
+        expect(() {hb.flush(2);}).toThrow('No more pending request to flush !');
+        expect(callback).toHaveBeenCalledOnce();
+      });
+
+
+      it('should throw exception when no request to flush', () {
+        expect(() {hb.flush();}).toThrow('No pending request to flush !');
+
+        hb.when('GET').respond(200, '');
+        hb('GET', '/some', null, callback);
+        hb.flush();
+
+        expect(() {hb.flush();}).toThrow('No pending request to flush !');
+      });
+
+
+      it('should throw exception if not all expectations satisfied', () {
+        hb.expect('GET', '/url1').respond();
+        hb.expect('GET', '/url2').respond();
+
+        hb('GET', '/url1', null, noop);
+        expect(() {hb.flush();}).toThrow('Unsatisfied requests: GET /url2');
+      });
+    });
+
+
+    it('should abort requests when timeout promise resolves', () {
+      hb.expect('GET', '/url1').respond(200);
+
+      var canceler, then = jasmine.createSpy('then').andCallFake((fn) {
+        canceler = fn;
+      });
+
+      hb('GET', '/url1', null, callback, null, new _Chain(then: then));
+      expect(canceler is Function).toBe(true);
+
+      canceler();  // simulate promise resolution
+
+      expect(callback).toHaveBeenCalledWith(-1, null, '');
+      hb.verifyNoOutstandingExpectation();
+      hb.verifyNoOutstandingRequest();
+    });
+
+
+    it('should throw an exception if no response defined', () {
+      hb.when('GET', '/test');
       expect(() {
-        hb('GET', '/url2', null, noop, {});
-      }).toThrow('Unexpected request: GET /url2\nExpected GET /url1');
-    });
-
-
-    it('should have precedence over when()', () {
-      callback.andCallFake((status, response) {
-        expect(status).toBe(299);
-        expect(response).toBe('expect');
-      });
-
-      hb.when('GET', '/url').respond(200, 'when');
-      hb.expect('GET', '/url').respond(299, 'expect');
-
-      hb('GET', '/url', null, callback, null);
-      hb.flush();
-      expect(callback).toHaveBeenCalledOnce();
-    });
-
-
-    it('should throw exception when only headers differs from expectation', () {
-      hb.when('GET', '/match').respond(200, '', {});
-      hb.expect('GET', '/match', null, {'Content-Type': 'application/json'}).respond(200, '', {});
-
+        hb('GET', '/test', null, callback);
+      }).toThrow('No response defined !');
+    });
+
+
+    it('should throw an exception if no response for exception and no definition', () {
+      hb.expect('GET', '/url');
       expect(() {
-        hb('GET', '/match', null, noop, {});
-      }).toThrow('Expected GET /match with different headers\n' +
-                 'EXPECTED: {"Content-Type":"application/json"}\nGOT:      {}');
-    });
-
-
-    it('should throw exception when only data differs from expectation', () {
-      hb.when('GET', '/match').respond(200, '', {});
-      hb.expect('GET', '/match', 'some-data').respond(200, '', {});
-
-      expect(() {
-        hb('GET', '/match', 'different', noop, null);
-      }).toThrow('Expected GET /match with different data\n' +
-                 'EXPECTED: some-data\nGOT:      different');
-    });
-
-
-    it("should use when's respond() when no expect() respond is defined", () {
-      callback.andCallFake((status, response) {
-        expect(status).toBe(201);
-        expect(response).toBe('data');
-      });
-
-      hb.when('GET', '/some').respond(201, 'data');
-      hb.expect('GET', '/some');
-      hb('GET', '/some', null, callback);
-      hb.flush();
-
-      expect(callback).toHaveBeenCalled();
-      expect(() { hb.verifyNoOutstandingExpectation(); }).not.toThrow();
-    });
-  });
-
-
-  describe('flush()', () {
-    it('flush() should flush requests fired during callbacks', () {
-      hb.when('GET', '/some').respond(200, '');
-      hb.when('GET', '/other').respond(200, '');
-      hb('GET', '/some', null, (_, __) {
-        hb('GET', '/other', null, callback);
-      });
-
-      hb.flush();
-      expect(callback).toHaveBeenCalled();
-    });
-
-
-    it('should flush given number of pending requests', () {
-      hb.when('GET').respond(200, '');
-      hb('GET', '/some', null, callback);
-      hb('GET', '/some', null, callback);
-      hb('GET', '/some', null, callback);
-
-      hb.flush(2);
-      expect(callback).toHaveBeenCalled();
-      expect(callback.callCount).toBe(2);
-    });
-
-
-    it('should throw exception when flushing more requests than pending', () {
-      hb.when('GET').respond(200, '');
-      hb('GET', '/url', null, callback);
-
-      expect(() {hb.flush(2);}).toThrow('No more pending request to flush !');
-      expect(callback).toHaveBeenCalledOnce();
-    });
-
-
-    it('should throw exception when no request to flush', () {
-      expect(() {hb.flush();}).toThrow('No pending request to flush !');
-
-      hb.when('GET').respond(200, '');
-      hb('GET', '/some', null, callback);
-      hb.flush();
-
-      expect(() {hb.flush();}).toThrow('No pending request to flush !');
-    });
-
-
-    it('should throw exception if not all expectations satisfied', () {
-      hb.expect('GET', '/url1').respond();
-      hb.expect('GET', '/url2').respond();
-
-      hb('GET', '/url1', null, noop);
-      expect(() {hb.flush();}).toThrow('Unsatisfied requests: GET /url2');
-    });
-  });
-
-
-  it('should abort requests when timeout promise resolves', () {
-    hb.expect('GET', '/url1').respond(200);
-
-    var canceler, then = jasmine.createSpy('then').andCallFake((fn) {
-      canceler = fn;
-    });
-
-    hb('GET', '/url1', null, callback, null, new _Chain(then: then));
-    expect(canceler is Function).toBe(true);
-
-    canceler();  // simulate promise resolution
-
-    expect(callback).toHaveBeenCalledWith(-1, null, '');
-    hb.verifyNoOutstandingExpectation();
-    hb.verifyNoOutstandingRequest();
-  });
-
-
-  it('should throw an exception if no response defined', () {
-    hb.when('GET', '/test');
-    expect(() {
-      hb('GET', '/test', null, callback);
-    }).toThrow('No response defined !');
-  });
-
-
-  it('should throw an exception if no response for exception and no definition', () {
-    hb.expect('GET', '/url');
-    expect(() {
-      hb('GET', '/url', null, callback);
-    }).toThrow('No response defined !');
-  });
-
-
-  it('should respond undefined when JSONP method', () {
-    hb.when('JSONP', '/url1').respond(200);
-    hb.expect('JSONP', '/url2').respond(200);
-
-    expect(hb('JSONP', '/url1')).toBeNull();
-    expect(hb('JSONP', '/url2')).toBeNull();
-  });
-
-
-  describe('verifyExpectations', () {
-
-    it('should throw exception if not all expectations were satisfied', () {
-      hb.expect('POST', '/u1', 'ddd').respond(201, '', {});
-      hb.expect('GET', '/u2').respond(200, '', {});
-      hb.expect('POST', '/u3').respond(201, '', {});
-
-      hb('POST', '/u1', 'ddd', noop, {});
-
-      expect(() {hb.verifyNoOutstandingExpectation();}).
+        hb('GET', '/url', null, callback);
+      }).toThrow('No response defined !');
+    });
+
+
+    it('should respond undefined when JSONP method', () {
+      hb.when('JSONP', '/url1').respond(200);
+      hb.expect('JSONP', '/url2').respond(200);
+
+      expect(hb('JSONP', '/url1')).toBeNull();
+      expect(hb('JSONP', '/url2')).toBeNull();
+    });
+
+
+    describe('verifyExpectations', () {
+
+      it('should throw exception if not all expectations were satisfied', () {
+        hb.expect('POST', '/u1', 'ddd').respond(201, '', {});
+        hb.expect('GET', '/u2').respond(200, '', {});
+        hb.expect('POST', '/u3').respond(201, '', {});
+
+        hb('POST', '/u1', 'ddd', noop, {});
+
+        expect(() {hb.verifyNoOutstandingExpectation();}).
         toThrow('Unsatisfied requests: GET /u2, POST /u3');
-    });
-
-
-    it('should do nothing when no expectation', () {
-      hb.when('DELETE', '/some').respond(200, '');
-
-      expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
-    });
-
-
-    it('should do nothing when all expectations satisfied', () {
-      hb.expect('GET', '/u2').respond(200, '', {});
-      hb.expect('POST', '/u3').respond(201, '', {});
-      hb.when('DELETE', '/some').respond(200, '');
-
-      hb('GET', '/u2');
-      hb('POST', '/u3');
-
-      expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
-    });
-  });
-
-  describe('verifyRequests', () {
-
-    it('should throw exception if not all requests were flushed', () {
-      hb.when('GET').respond(200);
-      hb('GET', '/some', null, noop, {});
-
-      expect(() {
-        hb.verifyNoOutstandingRequest();
-      }).toThrow('Unflushed requests: 1');
-    });
-  });
-
-
-  describe('resetExpectations', () {
-
-    it('should remove all expectations', () {
-      hb.expect('GET', '/u2').respond(200, '', {});
-      hb.expect('POST', '/u3').respond(201, '', {});
-      hb.resetExpectations();
-
-      expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
-    });
-
-
-    it('should remove all pending responses', () {
-      var cancelledClb = jasmine.createSpy('cancelled');
-
-      hb.expect('GET', '/url').respond(200, '');
-      hb('GET', '/url', null, cancelledClb);
-      hb.resetExpectations();
-
-      hb.expect('GET', '/url').respond(300, '');
-      hb('GET', '/url', null, callback, {});
-      hb.flush();
-
-      expect(callback).toHaveBeenCalledOnce();
-      expect(cancelledClb).not.toHaveBeenCalled();
-    });
-
-
-    it('should not remove definitions', () {
-      var cancelledClb = jasmine.createSpy('cancelled');
-
-      hb.when('GET', '/url').respond(200, 'success');
-      hb('GET', '/url', null, cancelledClb);
-      hb.resetExpectations();
-
-      hb('GET', '/url', null, callback, {});
-      hb.flush();
-
-      expect(callback).toHaveBeenCalledOnce();
-      expect(cancelledClb).not.toHaveBeenCalled();
-    });
-  });
-
-
-  describe('expect/when shortcuts', () {
-    [[(x) => hb.expectGET(x), 'GET'],
-     [(x) => hb.expectPOST(x), 'POST'],
-     [(x) => hb.expectPUT(x), 'PUT'],
-     [(x) => hb.expectPATCH(x), 'PATCH'],
-     [(x) => hb.expectDELETE(x), 'DELETE'],
-     [(x) => hb.expectJSONP(x), 'JSONP'],
-     [(x) => hb.whenGET(x), 'GET'],
-     [(x) => hb.whenPOST(x), 'POST'],
-     [(x) => hb.whenPUT(x), 'PUT'],
-     [(x) => hb.whenPATCH(x), 'PATCH'],
-     [(x) => hb.whenDELETE(x), 'DELETE'],
-     [(x) => hb.whenJSONP(x), 'JSONP']
-    ].forEach((step) {
+      });
+
+
+      it('should do nothing when no expectation', () {
+        hb.when('DELETE', '/some').respond(200, '');
+
+        expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+      });
+
+
+      it('should do nothing when all expectations satisfied', () {
+        hb.expect('GET', '/u2').respond(200, '', {});
+        hb.expect('POST', '/u3').respond(201, '', {});
+        hb.when('DELETE', '/some').respond(200, '');
+
+        hb('GET', '/u2');
+        hb('POST', '/u3');
+
+        expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+      });
+    });
+
+    describe('verifyRequests', () {
+
+      it('should throw exception if not all requests were flushed', () {
+        hb.when('GET').respond(200);
+        hb('GET', '/some', null, noop, {});
+
+        expect(() {
+          hb.verifyNoOutstandingRequest();
+        }).toThrow('Unflushed requests: 1');
+      });
+    });
+
+
+    describe('resetExpectations', () {
+
+      it('should remove all expectations', () {
+        hb.expect('GET', '/u2').respond(200, '', {});
+        hb.expect('POST', '/u3').respond(201, '', {});
+        hb.resetExpectations();
+
+        expect(() {hb.verifyNoOutstandingExpectation();}).not.toThrow();
+      });
+
+
+      it('should remove all pending responses', () {
+        var cancelledClb = jasmine.createSpy('cancelled');
+
+        hb.expect('GET', '/url').respond(200, '');
+        hb('GET', '/url', null, cancelledClb);
+        hb.resetExpectations();
+
+        hb.expect('GET', '/url').respond(300, '');
+        hb('GET', '/url', null, callback, {});
+        hb.flush();
+
+        expect(callback).toHaveBeenCalledOnce();
+        expect(cancelledClb).not.toHaveBeenCalled();
+      });
+
+
+      it('should not remove definitions', () {
+        var cancelledClb = jasmine.createSpy('cancelled');
+
+        hb.when('GET', '/url').respond(200, 'success');
+        hb('GET', '/url', null, cancelledClb);
+        hb.resetExpectations();
+
+        hb('GET', '/url', null, callback, {});
+        hb.flush();
+
+        expect(callback).toHaveBeenCalledOnce();
+        expect(cancelledClb).not.toHaveBeenCalled();
+      });
+    });
+
+
+    describe('expect/when shortcuts', () {
+      [[(x) => hb.expectGET(x), 'GET'],
+      [(x) => hb.expectPOST(x), 'POST'],
+      [(x) => hb.expectPUT(x), 'PUT'],
+      [(x) => hb.expectPATCH(x), 'PATCH'],
+      [(x) => hb.expectDELETE(x), 'DELETE'],
+      [(x) => hb.expectJSONP(x), 'JSONP'],
+      [(x) => hb.whenGET(x), 'GET'],
+      [(x) => hb.whenPOST(x), 'POST'],
+      [(x) => hb.whenPUT(x), 'PUT'],
+      [(x) => hb.whenPATCH(x), 'PATCH'],
+      [(x) => hb.whenDELETE(x), 'DELETE'],
+      [(x) => hb.whenJSONP(x), 'JSONP']
+      ].forEach((step) {
         var shortcut = step[0], method = step[1];
         it('should provide $shortcut  shortcut method', () {
           shortcut('/foo').respond('bar');
           hb(method, '/foo', undefined, callback);
           hb.flush();
           expect(callback).toHaveBeenCalledOnceWith(200, 'bar', '');
         });
       });
-  });
-
-
-  describe('MockHttpExpectation', () {
-
-    it('should accept url as regexp', () {
-      var exp = new MockHttpExpectation('GET', new RegExp('^\/x'));
-
-      expect(exp.match('GET', '/x')).toBe(true);
-      expect(exp.match('GET', '/xxx/x')).toBe(true);
-      expect(exp.match('GET', 'x')).toBe(false);
-      expect(exp.match('GET', 'a/x')).toBe(false);
     });
 
 
-    it('should accept data as regexp', () {
-      var exp = new MockHttpExpectation('POST', '/url', new RegExp('\{.*?\}'));
+    describe('MockHttpExpectation', () {
 
-      expect(exp.match('POST', '/url', '{"a": "aa"}')).toBe(true);
-      expect(exp.match('POST', '/url', '{"one": "two"}')).toBe(true);
-      expect(exp.match('POST', '/url', '{"one"')).toBe(false);
-    });
+      it('should accept url as regexp', () {
+        var exp = new MockHttpExpectation('GET', new RegExp('^\/x'));
+
+        expect(exp.match('GET', '/x')).toBe(true);
+        expect(exp.match('GET', '/xxx/x')).toBe(true);
+        expect(exp.match('GET', 'x')).toBe(false);
+        expect(exp.match('GET', 'a/x')).toBe(false);
+      });
 
 
-    it('should accept headers as function', () {
-      var exp = new MockHttpExpectation('GET', '/url', undefined, (h) {
-        return h['Content-Type'] == 'application/json';
+      it('should accept data as regexp', () {
+        var exp = new MockHttpExpectation('POST', '/url', new RegExp('\{.*?\}'));
+
+        expect(exp.match('POST', '/url', '{"a": "aa"}')).toBe(true);
+        expect(exp.match('POST', '/url', '{"one": "two"}')).toBe(true);
+        expect(exp.match('POST', '/url', '{"one"')).toBe(false);
       });
 
-      expect(exp.matchHeaders({})).toBe(false);
-      expect(exp.matchHeaders({'Content-Type': 'application/json', 'X-Another': 'true'})).toBe(true);
+
+      it('should accept headers as function', () {
+        var exp = new MockHttpExpectation('GET', '/url', undefined, (h) {
+          return h['Content-Type'] == 'application/json';
+        });
+
+        expect(exp.matchHeaders({})).toBe(false);
+        expect(exp.matchHeaders({'Content-Type': 'application/json', 'X-Another': 'true'})).toBe(true);
+      });
     });
   });
-});
+}