Roll of googleapis as of 4/7/2015.

generated/googleapis/test/blogger/v3_test.dart

 library googleapis.blogger.v3.test;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart' as http_testing;
 import 'package:unittest/unittest.dart' as unittest;
-import 'package:googleapis/common/common.dart' as common;
-import 'package:googleapis/src/common_internal.dart' as common_internal;
-import '../common/common_internal_test.dart' as common_test;
 
 import 'package:googleapis/blogger/v3.dart' as api;
 
+class HttpServerMock extends http.BaseClient {
+  core.Function _callback;
+  core.bool _expectJson;
 
+  void register(core.Function callback, core.bool expectJson) {
+    _callback = callback;
+    _expectJson = expectJson;
+  }
+
+  async.Future<http.StreamedResponse> send(http.BaseRequest request) {
+    if (_expectJson) {
+      return request.finalize()
+          .transform(convert.UTF8.decoder)
+          .join('')
+          .then((core.String jsonString) {
+        if (jsonString.isEmpty) {
+          return _callback(request, null);
+        } else {
+          return _callback(request, convert.JSON.decode(jsonString));
+        }
+      });
+    } else {
+      var stream = request.finalize();
+      if (stream == null) {
+        return _callback(request, []);
+      } else {
+        return stream.toBytes().then((data) {
+          return _callback(request, data);
+        });
+      }
+    }
+  }
+}
+
+http.StreamedResponse stringResponse(
+    core.int status, core.Map headers, core.String body) {
+  var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
+  return new http.StreamedResponse(stream, status, headers: headers);
+}
 
 core.int buildCounterBlogLocale = 0;
 buildBlogLocale() {
   var o = new api.BlogLocale();
   buildCounterBlogLocale++;
   if (buildCounterBlogLocale < 3) {
     o.country = "foo";
     o.language = "foo";
     o.variant = "foo";
   }
@@ skipping 25 matching lines @@
 
 checkBlogPages(api.BlogPages o) {
   buildCounterBlogPages++;
   if (buildCounterBlogPages < 3) {
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterBlogPages--;
 }
 
-buildUnnamed1026() {
+buildUnnamed309() {
   var o = new core.List<api.Post>();
   o.add(buildPost());
   o.add(buildPost());
   return o;
 }
 
-checkUnnamed1026(core.List<api.Post> o) {
+checkUnnamed309(core.List<api.Post> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPost(o[0]);
   checkPost(o[1]);
 }
 
 core.int buildCounterBlogPosts = 0;
 buildBlogPosts() {
   var o = new api.BlogPosts();
   buildCounterBlogPosts++;
   if (buildCounterBlogPosts < 3) {
-    o.items = buildUnnamed1026();
+    o.items = buildUnnamed309();
     o.selfLink = "foo";
     o.totalItems = 42;
   }
   buildCounterBlogPosts--;
   return o;
 }
 
 checkBlogPosts(api.BlogPosts o) {
   buildCounterBlogPosts++;
   if (buildCounterBlogPosts < 3) {
-    checkUnnamed1026(o.items);
+    checkUnnamed309(o.items);
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterBlogPosts--;
 }
 
 core.int buildCounterBlog = 0;
 buildBlog() {
   var o = new api.Blog();
   buildCounterBlog++;
@@ skipping 29 matching lines @@
     checkBlogPosts(o.posts);
     unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterBlog--;
 }
 
-buildUnnamed1027() {
+buildUnnamed310() {
   var o = new core.List<api.BlogUserInfo>();
   o.add(buildBlogUserInfo());
   o.add(buildBlogUserInfo());
   return o;
 }
 
-checkUnnamed1027(core.List<api.BlogUserInfo> o) {
+checkUnnamed310(core.List<api.BlogUserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBlogUserInfo(o[0]);
   checkBlogUserInfo(o[1]);
 }
 
-buildUnnamed1028() {
+buildUnnamed311() {
   var o = new core.List<api.Blog>();
   o.add(buildBlog());
   o.add(buildBlog());
   return o;
 }
 
-checkUnnamed1028(core.List<api.Blog> o) {
+checkUnnamed311(core.List<api.Blog> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBlog(o[0]);
   checkBlog(o[1]);
 }
 
 core.int buildCounterBlogList = 0;
 buildBlogList() {
   var o = new api.BlogList();
   buildCounterBlogList++;
   if (buildCounterBlogList < 3) {
-    o.blogUserInfos = buildUnnamed1027();
-    o.items = buildUnnamed1028();
+    o.blogUserInfos = buildUnnamed310();
+    o.items = buildUnnamed311();
     o.kind = "foo";
   }
   buildCounterBlogList--;
   return o;
 }
 
 checkBlogList(api.BlogList o) {
   buildCounterBlogList++;
   if (buildCounterBlogList < 3) {
-    checkUnnamed1027(o.blogUserInfos);
-    checkUnnamed1028(o.items);
+    checkUnnamed310(o.blogUserInfos);
+    checkUnnamed311(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterBlogList--;
 }
 
 core.int buildCounterBlogPerUserInfo = 0;
 buildBlogPerUserInfo() {
   var o = new api.BlogPerUserInfo();
   buildCounterBlogPerUserInfo++;
   if (buildCounterBlogPerUserInfo < 3) {
@@ skipping 177 matching lines @@
     unittest.expect(o.kind, unittest.equals('foo'));
     checkCommentPost(o.post);
     unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterComment--;
 }
 
-buildUnnamed1029() {
+buildUnnamed312() {
   var o = new core.List<api.Comment>();
   o.add(buildComment());
   o.add(buildComment());
   return o;
 }
 
-checkUnnamed1029(core.List<api.Comment> o) {
+checkUnnamed312(core.List<api.Comment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkComment(o[0]);
   checkComment(o[1]);
 }
 
 core.int buildCounterCommentList = 0;
 buildCommentList() {
   var o = new api.CommentList();
   buildCounterCommentList++;
   if (buildCounterCommentList < 3) {
-    o.items = buildUnnamed1029();
+    o.items = buildUnnamed312();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.prevPageToken = "foo";
   }
   buildCounterCommentList--;
   return o;
 }
 
 checkCommentList(api.CommentList o) {
   buildCounterCommentList++;
   if (buildCounterCommentList < 3) {
-    checkUnnamed1029(o.items);
+    checkUnnamed312(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
   }
   buildCounterCommentList--;
 }
 
 core.int buildCounterPageAuthorImage = 0;
 buildPageAuthorImage() {
   var o = new api.PageAuthorImage();
@@ skipping 91 matching lines @@
     unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterPage--;
 }
 
-buildUnnamed1030() {
+buildUnnamed313() {
   var o = new core.List<api.Page>();
   o.add(buildPage());
   o.add(buildPage());
   return o;
 }
 
-checkUnnamed1030(core.List<api.Page> o) {
+checkUnnamed313(core.List<api.Page> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPage(o[0]);
   checkPage(o[1]);
 }
 
 core.int buildCounterPageList = 0;
 buildPageList() {
   var o = new api.PageList();
   buildCounterPageList++;
   if (buildCounterPageList < 3) {
-    o.items = buildUnnamed1030();
+    o.items = buildUnnamed313();
     o.kind = "foo";
     o.nextPageToken = "foo";
   }
   buildCounterPageList--;
   return o;
 }
 
 checkPageList(api.PageList o) {
   buildCounterPageList++;
   if (buildCounterPageList < 3) {
-    checkUnnamed1030(o.items);
+    checkUnnamed313(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterPageList--;
 }
 
 core.int buildCounterPageviewsCounts = 0;
 buildPageviewsCounts() {
   var o = new api.PageviewsCounts();
   buildCounterPageviewsCounts++;
   if (buildCounterPageviewsCounts < 3) {
     o.count = "foo";
     o.timeRange = "foo";
   }
   buildCounterPageviewsCounts--;
   return o;
 }
 
 checkPageviewsCounts(api.PageviewsCounts o) {
   buildCounterPageviewsCounts++;
   if (buildCounterPageviewsCounts < 3) {
     unittest.expect(o.count, unittest.equals('foo'));
     unittest.expect(o.timeRange, unittest.equals('foo'));
   }
   buildCounterPageviewsCounts--;
 }
 
-buildUnnamed1031() {
+buildUnnamed314() {
   var o = new core.List<api.PageviewsCounts>();
   o.add(buildPageviewsCounts());
   o.add(buildPageviewsCounts());
   return o;
 }
 
-checkUnnamed1031(core.List<api.PageviewsCounts> o) {
+checkUnnamed314(core.List<api.PageviewsCounts> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPageviewsCounts(o[0]);
   checkPageviewsCounts(o[1]);
 }
 
 core.int buildCounterPageviews = 0;
 buildPageviews() {
   var o = new api.Pageviews();
   buildCounterPageviews++;
   if (buildCounterPageviews < 3) {
     o.blogId = "foo";
-    o.counts = buildUnnamed1031();
+    o.counts = buildUnnamed314();
     o.kind = "foo";
   }
   buildCounterPageviews--;
   return o;
 }
 
 checkPageviews(api.Pageviews o) {
   buildCounterPageviews++;
   if (buildCounterPageviews < 3) {
     unittest.expect(o.blogId, unittest.equals('foo'));
-    checkUnnamed1031(o.counts);
+    checkUnnamed314(o.counts);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterPageviews--;
 }
 
 core.int buildCounterPostAuthorImage = 0;
 buildPostAuthorImage() {
   var o = new api.PostAuthorImage();
   buildCounterPostAuthorImage++;
   if (buildCounterPostAuthorImage < 3) {
@@ skipping 67 matching lines @@
 }
 
 checkPostImages(api.PostImages o) {
   buildCounterPostImages++;
   if (buildCounterPostImages < 3) {
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterPostImages--;
 }
 
-buildUnnamed1032() {
+buildUnnamed315() {
   var o = new core.List<api.PostImages>();
   o.add(buildPostImages());
   o.add(buildPostImages());
   return o;
 }
 
-checkUnnamed1032(core.List<api.PostImages> o) {
+checkUnnamed315(core.List<api.PostImages> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPostImages(o[0]);
   checkPostImages(o[1]);
 }
 
-buildUnnamed1033() {
+buildUnnamed316() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1033(core.List<core.String> o) {
+checkUnnamed316(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 core.int buildCounterPostLocation = 0;
 buildPostLocation() {
   var o = new api.PostLocation();
   buildCounterPostLocation++;
   if (buildCounterPostLocation < 3) {
@@ skipping 10 matching lines @@
   buildCounterPostLocation++;
   if (buildCounterPostLocation < 3) {
     unittest.expect(o.lat, unittest.equals(42.0));
     unittest.expect(o.lng, unittest.equals(42.0));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.span, unittest.equals('foo'));
   }
   buildCounterPostLocation--;
 }
 
-buildUnnamed1034() {
+buildUnnamed317() {
   var o = new core.List<api.Comment>();
   o.add(buildComment());
   o.add(buildComment());
   return o;
 }
 
-checkUnnamed1034(core.List<api.Comment> o) {
+checkUnnamed317(core.List<api.Comment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkComment(o[0]);
   checkComment(o[1]);
 }
 
 core.int buildCounterPostReplies = 0;
 buildPostReplies() {
   var o = new api.PostReplies();
   buildCounterPostReplies++;
   if (buildCounterPostReplies < 3) {
-    o.items = buildUnnamed1034();
+    o.items = buildUnnamed317();
     o.selfLink = "foo";
     o.totalItems = "foo";
   }
   buildCounterPostReplies--;
   return o;
 }
 
 checkPostReplies(api.PostReplies o) {
   buildCounterPostReplies++;
   if (buildCounterPostReplies < 3) {
-    checkUnnamed1034(o.items);
+    checkUnnamed317(o.items);
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals('foo'));
   }
   buildCounterPostReplies--;
 }
 
 core.int buildCounterPost = 0;
 buildPost() {
   var o = new api.Post();
   buildCounterPost++;
   if (buildCounterPost < 3) {
     o.author = buildPostAuthor();
     o.blog = buildPostBlog();
     o.content = "foo";
     o.customMetaData = "foo";
     o.etag = "foo";
     o.id = "foo";
-    o.images = buildUnnamed1032();
+    o.images = buildUnnamed315();
     o.kind = "foo";
-    o.labels = buildUnnamed1033();
+    o.labels = buildUnnamed316();
     o.location = buildPostLocation();
     o.published = core.DateTime.parse("2002-02-27T14:01:02");
     o.readerComments = "foo";
     o.replies = buildPostReplies();
     o.selfLink = "foo";
     o.status = "foo";
     o.title = "foo";
     o.titleLink = "foo";
     o.updated = core.DateTime.parse("2002-02-27T14:01:02");
     o.url = "foo";
   }
   buildCounterPost--;
   return o;
 }
 
 checkPost(api.Post o) {
   buildCounterPost++;
   if (buildCounterPost < 3) {
     checkPostAuthor(o.author);
     checkPostBlog(o.blog);
     unittest.expect(o.content, unittest.equals('foo'));
     unittest.expect(o.customMetaData, unittest.equals('foo'));
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed1032(o.images);
+    checkUnnamed315(o.images);
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed1033(o.labels);
+    checkUnnamed316(o.labels);
     checkPostLocation(o.location);
     unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.readerComments, unittest.equals('foo'));
     checkPostReplies(o.replies);
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.titleLink, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterPost--;
 }
 
-buildUnnamed1035() {
+buildUnnamed318() {
   var o = new core.List<api.Post>();
   o.add(buildPost());
   o.add(buildPost());
   return o;
 }
 
-checkUnnamed1035(core.List<api.Post> o) {
+checkUnnamed318(core.List<api.Post> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPost(o[0]);
   checkPost(o[1]);
 }
 
 core.int buildCounterPostList = 0;
 buildPostList() {
   var o = new api.PostList();
   buildCounterPostList++;
   if (buildCounterPostList < 3) {
-    o.items = buildUnnamed1035();
+    o.items = buildUnnamed318();
     o.kind = "foo";
     o.nextPageToken = "foo";
   }
   buildCounterPostList--;
   return o;
 }
 
 checkPostList(api.PostList o) {
   buildCounterPostList++;
   if (buildCounterPostList < 3) {
-    checkUnnamed1035(o.items);
+    checkUnnamed318(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterPostList--;
 }
 
 core.int buildCounterPostPerUserInfo = 0;
 buildPostPerUserInfo() {
   var o = new api.PostPerUserInfo();
   buildCounterPostPerUserInfo++;
@@ skipping 36 matching lines @@
 checkPostUserInfo(api.PostUserInfo o) {
   buildCounterPostUserInfo++;
   if (buildCounterPostUserInfo < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     checkPost(o.post);
     checkPostPerUserInfo(o.postUserInfo);
   }
   buildCounterPostUserInfo--;
 }
 
-buildUnnamed1036() {
+buildUnnamed319() {
   var o = new core.List<api.PostUserInfo>();
   o.add(buildPostUserInfo());
   o.add(buildPostUserInfo());
   return o;
 }
 
-checkUnnamed1036(core.List<api.PostUserInfo> o) {
+checkUnnamed319(core.List<api.PostUserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPostUserInfo(o[0]);
   checkPostUserInfo(o[1]);
 }
 
 core.int buildCounterPostUserInfosList = 0;
 buildPostUserInfosList() {
   var o = new api.PostUserInfosList();
   buildCounterPostUserInfosList++;
   if (buildCounterPostUserInfosList < 3) {
-    o.items = buildUnnamed1036();
+    o.items = buildUnnamed319();
     o.kind = "foo";
     o.nextPageToken = "foo";
   }
   buildCounterPostUserInfosList--;
   return o;
 }
 
 checkPostUserInfosList(api.PostUserInfosList o) {
   buildCounterPostUserInfosList++;
   if (buildCounterPostUserInfosList < 3) {
-    checkUnnamed1036(o.items);
+    checkUnnamed319(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterPostUserInfosList--;
 }
 
 core.int buildCounterUserBlogs = 0;
 buildUserBlogs() {
   var o = new api.UserBlogs();
   buildCounterUserBlogs++;
@@ skipping 63 matching lines @@
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkUserLocale(o.locale);
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterUser--;
 }
 
-buildUnnamed1037() {
+buildUnnamed320() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1037(core.List<core.String> o) {
+checkUnnamed320(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1038() {
+buildUnnamed321() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1038(core.List<core.String> o) {
+checkUnnamed321(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1039() {
+buildUnnamed322() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1039(core.List<core.String> o) {
+checkUnnamed322(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1040() {
+buildUnnamed323() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1040(core.List<core.String> o) {
+checkUnnamed323(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1041() {
+buildUnnamed324() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1041(core.List<core.String> o) {
+checkUnnamed324(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1042() {
+buildUnnamed325() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1042(core.List<core.String> o) {
+checkUnnamed325(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1043() {
+buildUnnamed326() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1043(core.List<core.String> o) {
+checkUnnamed326(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1044() {
+buildUnnamed327() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1044(core.List<core.String> o) {
+checkUnnamed327(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
 
 main() {
   unittest.group("obj-schema-BlogLocale", () {
     unittest.test("to-json--from-json", () {
       var o = buildBlogLocale();
@@ skipping 305 matching lines @@
       var o = buildUser();
       var od = new api.User.fromJson(o.toJson());
       checkUser(od);
     });
   });
 
 
   unittest.group("resource-BlogUserInfosResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BlogUserInfosResourceApi res = new api.BloggerApi(mock).blogUserInfos;
       var arg_userId = "foo";
       var arg_blogId = "foo";
       var arg_maxPosts = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 29 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(core.int.parse(queryMap["maxPosts"].first), unittest.equals(arg_maxPosts));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBlogUserInfo());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_userId, arg_blogId, maxPosts: arg_maxPosts).then(unittest.expectAsync(((api.BlogUserInfo response) {
         checkBlogUserInfo(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-BlogsResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BlogsResourceApi res = new api.BloggerApi(mock).blogs;
       var arg_blogId = "foo";
       var arg_maxPosts = 42;
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 23 matching lines @@
           }
         }
         unittest.expect(core.int.parse(queryMap["maxPosts"].first), unittest.equals(arg_maxPosts));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBlog());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_blogId, maxPosts: arg_maxPosts, view: arg_view).then(unittest.expectAsync(((api.Blog response) {
         checkBlog(response);
       })));
     });
 
     unittest.test("method--getByUrl", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BlogsResourceApi res = new api.BloggerApi(mock).blogs;
       var arg_url = "foo";
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 19 matching lines @@
           }
         }
         unittest.expect(queryMap["url"].first, unittest.equals(arg_url));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBlog());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getByUrl(arg_url, view: arg_view).then(unittest.expectAsync(((api.Blog response) {
         checkBlog(response);
       })));
     });
 
     unittest.test("method--listByUser", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BlogsResourceApi res = new api.BloggerApi(mock).blogs;
       var arg_userId = "foo";
       var arg_fetchUserInfo = true;
-      var arg_role = buildUnnamed1037();
-      var arg_status = buildUnnamed1038();
+      var arg_role = buildUnnamed320();
+      var arg_status = buildUnnamed321();
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
@@ skipping 26 matching lines @@
         unittest.expect(queryMap["fetchUserInfo"].first, unittest.equals("$arg_fetchUserInfo"));
         unittest.expect(queryMap["role"], unittest.equals(arg_role));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBlogList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listByUser(arg_userId, fetchUserInfo: arg_fetchUserInfo, role: arg_role, status: arg_status, view: arg_view).then(unittest.expectAsync(((api.BlogList response) {
         checkBlogList(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-CommentsResourceApi", () {
     unittest.test("method--approve", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_commentId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 39 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.approve(arg_blogId, arg_postId, arg_commentId).then(unittest.expectAsync(((api.Comment response) {
         checkComment(response);
       })));
     });
 
     unittest.test("method--delete", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_commentId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 35 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = "";
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_blogId, arg_postId, arg_commentId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_commentId = "foo";
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 37 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_blogId, arg_postId, arg_commentId, view: arg_view).then(unittest.expectAsync(((api.Comment response) {
         checkComment(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_endDate = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_fetchBodies = true;
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_startDate = core.DateTime.parse("2002-02-27T14:01:02");
-      var arg_status = buildUnnamed1039();
+      var arg_status = buildUnnamed322();
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
@@ skipping 36 matching lines @@
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(core.DateTime.parse(queryMap["startDate"].first), unittest.equals(arg_startDate));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_blogId, arg_postId, endDate: arg_endDate, fetchBodies: arg_fetchBodies, maxResults: arg_maxResults, pageToken: arg_pageToken, startDate: arg_startDate, status: arg_status, view: arg_view).then(unittest.expectAsync(((api.CommentList response) {
         checkCommentList(response);
       })));
     });
 
     unittest.test("method--listByBlog", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_endDate = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_fetchBodies = true;
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_startDate = core.DateTime.parse("2002-02-27T14:01:02");
-      var arg_status = buildUnnamed1040();
+      var arg_status = buildUnnamed323();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
         unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("blogs/"));
@@ skipping 27 matching lines @@
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(core.DateTime.parse(queryMap["startDate"].first), unittest.equals(arg_startDate));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listByBlog(arg_blogId, endDate: arg_endDate, fetchBodies: arg_fetchBodies, maxResults: arg_maxResults, pageToken: arg_pageToken, startDate: arg_startDate, status: arg_status).then(unittest.expectAsync(((api.CommentList response) {
         checkCommentList(response);
       })));
     });
 
     unittest.test("method--markAsSpam", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_commentId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 39 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.markAsSpam(arg_blogId, arg_postId, arg_commentId).then(unittest.expectAsync(((api.Comment response) {
         checkComment(response);
       })));
     });
 
     unittest.test("method--removeContent", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.BloggerApi(mock).comments;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_commentId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 39 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.removeContent(arg_blogId, arg_postId, arg_commentId).then(unittest.expectAsync(((api.Comment response) {
         checkComment(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-PageViewsResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PageViewsResourceApi res = new api.BloggerApi(mock).pageViews;
       var arg_blogId = "foo";
-      var arg_range = buildUnnamed1041();
+      var arg_range = buildUnnamed324();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
         unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("blogs/"));
@@ skipping 22 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["range"], unittest.equals(arg_range));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPageviews());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_blogId, range: arg_range).then(unittest.expectAsync(((api.Pageviews response) {
         checkPageviews(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-PagesResourceApi", () {
     unittest.test("method--delete", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 27 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = "";
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_blogId, arg_pageId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 29 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_blogId, arg_pageId, view: arg_view).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
     unittest.test("method--insert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_request = buildPage();
       var arg_blogId = "foo";
       var arg_isDraft = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Page.fromJson(json);
         checkPage(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 29 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["isDraft"].first, unittest.equals("$arg_isDraft"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.insert(arg_request, arg_blogId, isDraft: arg_isDraft).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_blogId = "foo";
       var arg_fetchBodies = true;
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
-      var arg_status = buildUnnamed1042();
+      var arg_status = buildUnnamed325();
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
@@ skipping 27 matching lines @@
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPageList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_blogId, fetchBodies: arg_fetchBodies, maxResults: arg_maxResults, pageToken: arg_pageToken, status: arg_status, view: arg_view).then(unittest.expectAsync(((api.PageList response) {
         checkPageList(response);
       })));
     });
 
     unittest.test("method--patch", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_request = buildPage();
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       var arg_publish_1 = true;
       var arg_revert_1 = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Page.fromJson(json);
         checkPage(obj);
 
@@ skipping 35 matching lines @@
           }
         }
         unittest.expect(queryMap["publish"].first, unittest.equals("$arg_publish_1"));
         unittest.expect(queryMap["revert"].first, unittest.equals("$arg_revert_1"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.patch(arg_request, arg_blogId, arg_pageId, publish_1: arg_publish_1, revert_1: arg_revert_1).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
     unittest.test("method--publish", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 31 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.publish(arg_blogId, arg_pageId).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
     unittest.test("method--revert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 31 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.revert(arg_blogId, arg_pageId).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
     unittest.test("method--update", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PagesResourceApi res = new api.BloggerApi(mock).pages;
       var arg_request = buildPage();
       var arg_blogId = "foo";
       var arg_pageId = "foo";
       var arg_publish_1 = true;
       var arg_revert_1 = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Page.fromJson(json);
         checkPage(obj);
 
@@ skipping 35 matching lines @@
           }
         }
         unittest.expect(queryMap["publish"].first, unittest.equals("$arg_publish_1"));
         unittest.expect(queryMap["revert"].first, unittest.equals("$arg_revert_1"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPage());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.update(arg_request, arg_blogId, arg_pageId, publish_1: arg_publish_1, revert_1: arg_revert_1).then(unittest.expectAsync(((api.Page response) {
         checkPage(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-PostUserInfosResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostUserInfosResourceApi res = new api.BloggerApi(mock).postUserInfos;
       var arg_userId = "foo";
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_maxComments = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 37 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(core.int.parse(queryMap["maxComments"].first), unittest.equals(arg_maxComments));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPostUserInfo());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_userId, arg_blogId, arg_postId, maxComments: arg_maxComments).then(unittest.expectAsync(((api.PostUserInfo response) {
         checkPostUserInfo(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostUserInfosResourceApi res = new api.BloggerApi(mock).postUserInfos;
       var arg_userId = "foo";
       var arg_blogId = "foo";
       var arg_endDate = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_fetchBodies = true;
       var arg_labels = "foo";
       var arg_maxResults = 42;
       var arg_orderBy = "foo";
       var arg_pageToken = "foo";
       var arg_startDate = core.DateTime.parse("2002-02-27T14:01:02");
-      var arg_status = buildUnnamed1043();
+      var arg_status = buildUnnamed326();
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
@@ skipping 38 matching lines @@
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(core.DateTime.parse(queryMap["startDate"].first), unittest.equals(arg_startDate));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPostUserInfosList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_userId, arg_blogId, endDate: arg_endDate, fetchBodies: arg_fetchBodies, labels: arg_labels, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken, startDate: arg_startDate, status: arg_status, view: arg_view).then(unittest.expectAsync(((api.PostUserInfosList response) {
         checkPostUserInfosList(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-PostsResourceApi", () {
     unittest.test("method--delete", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 27 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = "";
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_blogId, arg_postId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_fetchBody = true;
       var arg_fetchImages = true;
       var arg_maxComments = 42;
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 35 matching lines @@
         unittest.expect(queryMap["fetchBody"].first, unittest.equals("$arg_fetchBody"));
         unittest.expect(queryMap["fetchImages"].first, unittest.equals("$arg_fetchImages"));
         unittest.expect(core.int.parse(queryMap["maxComments"].first), unittest.equals(arg_maxComments));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_blogId, arg_postId, fetchBody: arg_fetchBody, fetchImages: arg_fetchImages, maxComments: arg_maxComments, view: arg_view).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--getByPath", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_path = "foo";
       var arg_maxComments = 42;
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 29 matching lines @@
         }
         unittest.expect(queryMap["path"].first, unittest.equals(arg_path));
         unittest.expect(core.int.parse(queryMap["maxComments"].first), unittest.equals(arg_maxComments));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getByPath(arg_blogId, arg_path, maxComments: arg_maxComments, view: arg_view).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--insert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_request = buildPost();
       var arg_blogId = "foo";
       var arg_fetchBody = true;
       var arg_fetchImages = true;
       var arg_isDraft = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Post.fromJson(json);
         checkPost(obj);
 
@@ skipping 33 matching lines @@
         }
         unittest.expect(queryMap["fetchBody"].first, unittest.equals("$arg_fetchBody"));
         unittest.expect(queryMap["fetchImages"].first, unittest.equals("$arg_fetchImages"));
         unittest.expect(queryMap["isDraft"].first, unittest.equals("$arg_isDraft"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.insert(arg_request, arg_blogId, fetchBody: arg_fetchBody, fetchImages: arg_fetchImages, isDraft: arg_isDraft).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_endDate = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_fetchBodies = true;
       var arg_fetchImages = true;
       var arg_labels = "foo";
       var arg_maxResults = 42;
       var arg_orderBy = "foo";
       var arg_pageToken = "foo";
       var arg_startDate = core.DateTime.parse("2002-02-27T14:01:02");
-      var arg_status = buildUnnamed1044();
+      var arg_status = buildUnnamed327();
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
         pathOffset += 11;
@@ skipping 32 matching lines @@
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(core.DateTime.parse(queryMap["startDate"].first), unittest.equals(arg_startDate));
         unittest.expect(queryMap["status"], unittest.equals(arg_status));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPostList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_blogId, endDate: arg_endDate, fetchBodies: arg_fetchBodies, fetchImages: arg_fetchImages, labels: arg_labels, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken, startDate: arg_startDate, status: arg_status, view: arg_view).then(unittest.expectAsync(((api.PostList response) {
         checkPostList(response);
       })));
     });
 
     unittest.test("method--patch", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_request = buildPost();
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_fetchBody = true;
       var arg_fetchImages = true;
       var arg_maxComments = 42;
       var arg_publish_1 = true;
       var arg_revert_1 = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 41 matching lines @@
         unittest.expect(queryMap["fetchImages"].first, unittest.equals("$arg_fetchImages"));
         unittest.expect(core.int.parse(queryMap["maxComments"].first), unittest.equals(arg_maxComments));
         unittest.expect(queryMap["publish"].first, unittest.equals("$arg_publish_1"));
         unittest.expect(queryMap["revert"].first, unittest.equals("$arg_revert_1"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.patch(arg_request, arg_blogId, arg_postId, fetchBody: arg_fetchBody, fetchImages: arg_fetchImages, maxComments: arg_maxComments, publish_1: arg_publish_1, revert_1: arg_revert_1).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--publish", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_publishDate = core.DateTime.parse("2002-02-27T14:01:02");
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
@@ skipping 33 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(core.DateTime.parse(queryMap["publishDate"].first), unittest.equals(arg_publishDate));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.publish(arg_blogId, arg_postId, publishDate: arg_publishDate).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--revert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_postId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
@@ skipping 31 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.revert(arg_blogId, arg_postId).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
     unittest.test("method--search", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_blogId = "foo";
       var arg_q = "foo";
       var arg_fetchBodies = true;
       var arg_orderBy = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 29 matching lines @@
         }
         unittest.expect(queryMap["q"].first, unittest.equals(arg_q));
         unittest.expect(queryMap["fetchBodies"].first, unittest.equals("$arg_fetchBodies"));
         unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPostList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.search(arg_blogId, arg_q, fetchBodies: arg_fetchBodies, orderBy: arg_orderBy).then(unittest.expectAsync(((api.PostList response) {
         checkPostList(response);
       })));
     });
 
     unittest.test("method--update", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PostsResourceApi res = new api.BloggerApi(mock).posts;
       var arg_request = buildPost();
       var arg_blogId = "foo";
       var arg_postId = "foo";
       var arg_fetchBody = true;
       var arg_fetchImages = true;
       var arg_maxComments = 42;
       var arg_publish_1 = true;
       var arg_revert_1 = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 41 matching lines @@
         unittest.expect(queryMap["fetchImages"].first, unittest.equals("$arg_fetchImages"));
         unittest.expect(core.int.parse(queryMap["maxComments"].first), unittest.equals(arg_maxComments));
         unittest.expect(queryMap["publish"].first, unittest.equals("$arg_publish_1"));
         unittest.expect(queryMap["revert"].first, unittest.equals("$arg_revert_1"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPost());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.update(arg_request, arg_blogId, arg_postId, fetchBody: arg_fetchBody, fetchImages: arg_fetchImages, maxComments: arg_maxComments, publish_1: arg_publish_1, revert_1: arg_revert_1).then(unittest.expectAsync(((api.Post response) {
         checkPost(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-UsersResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.UsersResourceApi res = new api.BloggerApi(mock).users;
       var arg_userId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
         unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("blogger/v3/"));
@@ skipping 19 matching lines @@
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildUser());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_userId).then(unittest.expectAsync(((api.User response) {
         checkUser(response);
       })));
     });
 
   });
 
 
 }