Roll of googleapis as of 4/7/2015.

generated/googleapis/test/books/v1_test.dart

 library googleapis.books.v1.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/books/v1.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 buildCounterAnnotationClientVersionRanges = 0;
 buildAnnotationClientVersionRanges() {
   var o = new api.AnnotationClientVersionRanges();
   buildCounterAnnotationClientVersionRanges++;
   if (buildCounterAnnotationClientVersionRanges < 3) {
     o.cfiRange = buildBooksAnnotationsRange();
     o.contentVersion = "foo";
     o.gbImageRange = buildBooksAnnotationsRange();
     o.gbTextRange = buildBooksAnnotationsRange();
@@ skipping 58 matching lines @@
 checkAnnotationLayerSummary(api.AnnotationLayerSummary o) {
   buildCounterAnnotationLayerSummary++;
   if (buildCounterAnnotationLayerSummary < 3) {
     unittest.expect(o.allowedCharacterCount, unittest.equals(42));
     unittest.expect(o.limitType, unittest.equals('foo'));
     unittest.expect(o.remainingCharacterCount, unittest.equals(42));
   }
   buildCounterAnnotationLayerSummary--;
 }
 
-buildUnnamed806() {
+buildUnnamed328() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed806(core.List<core.String> o) {
+checkUnnamed328(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 buildCounterAnnotation = 0;
 buildAnnotation() {
   var o = new api.Annotation();
   buildCounterAnnotation++;
   if (buildCounterAnnotation < 3) {
     o.afterSelectedText = "foo";
     o.beforeSelectedText = "foo";
     o.clientVersionRanges = buildAnnotationClientVersionRanges();
     o.created = core.DateTime.parse("2002-02-27T14:01:02");
     o.currentVersionRanges = buildAnnotationCurrentVersionRanges();
     o.data = "foo";
     o.deleted = true;
     o.highlightStyle = "foo";
     o.id = "foo";
     o.kind = "foo";
     o.layerId = "foo";
     o.layerSummary = buildAnnotationLayerSummary();
-    o.pageIds = buildUnnamed806();
+    o.pageIds = buildUnnamed328();
     o.selectedText = "foo";
     o.selfLink = "foo";
     o.updated = core.DateTime.parse("2002-02-27T14:01:02");
     o.volumeId = "foo";
   }
   buildCounterAnnotation--;
   return o;
 }
 
 checkAnnotation(api.Annotation o) {
   buildCounterAnnotation++;
   if (buildCounterAnnotation < 3) {
     unittest.expect(o.afterSelectedText, unittest.equals('foo'));
     unittest.expect(o.beforeSelectedText, unittest.equals('foo'));
     checkAnnotationClientVersionRanges(o.clientVersionRanges);
     unittest.expect(o.created, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkAnnotationCurrentVersionRanges(o.currentVersionRanges);
     unittest.expect(o.data, unittest.equals('foo'));
     unittest.expect(o.deleted, unittest.isTrue);
     unittest.expect(o.highlightStyle, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.layerId, unittest.equals('foo'));
     checkAnnotationLayerSummary(o.layerSummary);
-    checkUnnamed806(o.pageIds);
+    checkUnnamed328(o.pageIds);
     unittest.expect(o.selectedText, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.volumeId, unittest.equals('foo'));
   }
   buildCounterAnnotation--;
 }
 
 core.int buildCounterAnnotationdata = 0;
 buildAnnotationdata() {
@@ skipping 23 matching lines @@
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.layerId, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.volumeId, unittest.equals('foo'));
   }
   buildCounterAnnotationdata--;
 }
 
-buildUnnamed807() {
+buildUnnamed329() {
   var o = new core.List<api.Annotation>();
   o.add(buildAnnotation());
   o.add(buildAnnotation());
   return o;
 }
 
-checkUnnamed807(core.List<api.Annotation> o) {
+checkUnnamed329(core.List<api.Annotation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotation(o[0]);
   checkAnnotation(o[1]);
 }
 
 core.int buildCounterAnnotations = 0;
 buildAnnotations() {
   var o = new api.Annotations();
   buildCounterAnnotations++;
   if (buildCounterAnnotations < 3) {
-    o.items = buildUnnamed807();
+    o.items = buildUnnamed329();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.totalItems = 42;
   }
   buildCounterAnnotations--;
   return o;
 }
 
 checkAnnotations(api.Annotations o) {
   buildCounterAnnotations++;
   if (buildCounterAnnotations < 3) {
-    checkUnnamed807(o.items);
+    checkUnnamed329(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterAnnotations--;
 }
 
 core.int buildCounterAnnotationsSummaryLayers = 0;
 buildAnnotationsSummaryLayers() {
   var o = new api.AnnotationsSummaryLayers();
@@ skipping 14 matching lines @@
   if (buildCounterAnnotationsSummaryLayers < 3) {
     unittest.expect(o.allowedCharacterCount, unittest.equals(42));
     unittest.expect(o.layerId, unittest.equals('foo'));
     unittest.expect(o.limitType, unittest.equals('foo'));
     unittest.expect(o.remainingCharacterCount, unittest.equals(42));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterAnnotationsSummaryLayers--;
 }
 
-buildUnnamed808() {
+buildUnnamed330() {
   var o = new core.List<api.AnnotationsSummaryLayers>();
   o.add(buildAnnotationsSummaryLayers());
   o.add(buildAnnotationsSummaryLayers());
   return o;
 }
 
-checkUnnamed808(core.List<api.AnnotationsSummaryLayers> o) {
+checkUnnamed330(core.List<api.AnnotationsSummaryLayers> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotationsSummaryLayers(o[0]);
   checkAnnotationsSummaryLayers(o[1]);
 }
 
 core.int buildCounterAnnotationsSummary = 0;
 buildAnnotationsSummary() {
   var o = new api.AnnotationsSummary();
   buildCounterAnnotationsSummary++;
   if (buildCounterAnnotationsSummary < 3) {
     o.kind = "foo";
-    o.layers = buildUnnamed808();
+    o.layers = buildUnnamed330();
   }
   buildCounterAnnotationsSummary--;
   return o;
 }
 
 checkAnnotationsSummary(api.AnnotationsSummary o) {
   buildCounterAnnotationsSummary++;
   if (buildCounterAnnotationsSummary < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed808(o.layers);
+    checkUnnamed330(o.layers);
   }
   buildCounterAnnotationsSummary--;
 }
 
-buildUnnamed809() {
+buildUnnamed331() {
   var o = new core.List<api.Annotationdata>();
   o.add(buildAnnotationdata());
   o.add(buildAnnotationdata());
   return o;
 }
 
-checkUnnamed809(core.List<api.Annotationdata> o) {
+checkUnnamed331(core.List<api.Annotationdata> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAnnotationdata(o[0]);
   checkAnnotationdata(o[1]);
 }
 
 core.int buildCounterAnnotationsdata = 0;
 buildAnnotationsdata() {
   var o = new api.Annotationsdata();
   buildCounterAnnotationsdata++;
   if (buildCounterAnnotationsdata < 3) {
-    o.items = buildUnnamed809();
+    o.items = buildUnnamed331();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.totalItems = 42;
   }
   buildCounterAnnotationsdata--;
   return o;
 }
 
 checkAnnotationsdata(api.Annotationsdata o) {
   buildCounterAnnotationsdata++;
   if (buildCounterAnnotationsdata < 3) {
-    checkUnnamed809(o.items);
+    checkUnnamed331(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterAnnotationsdata--;
 }
 
 core.int buildCounterBooksAnnotationsRange = 0;
 buildBooksAnnotationsRange() {
   var o = new api.BooksAnnotationsRange();
@@ skipping 93 matching lines @@
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.selfLink, 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.volumeCount, unittest.equals(42));
     unittest.expect(o.volumesLastUpdated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterBookshelf--;
 }
 
-buildUnnamed810() {
+buildUnnamed332() {
   var o = new core.List<api.Bookshelf>();
   o.add(buildBookshelf());
   o.add(buildBookshelf());
   return o;
 }
 
-checkUnnamed810(core.List<api.Bookshelf> o) {
+checkUnnamed332(core.List<api.Bookshelf> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBookshelf(o[0]);
   checkBookshelf(o[1]);
 }
 
 core.int buildCounterBookshelves = 0;
 buildBookshelves() {
   var o = new api.Bookshelves();
   buildCounterBookshelves++;
   if (buildCounterBookshelves < 3) {
-    o.items = buildUnnamed810();
+    o.items = buildUnnamed332();
     o.kind = "foo";
   }
   buildCounterBookshelves--;
   return o;
 }
 
 checkBookshelves(api.Bookshelves o) {
   buildCounterBookshelves++;
   if (buildCounterBookshelves < 3) {
-    checkUnnamed810(o.items);
+    checkUnnamed332(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterBookshelves--;
 }
 
 core.int buildCounterCategoryItems = 0;
 buildCategoryItems() {
   var o = new api.CategoryItems();
   buildCounterCategoryItems++;
   if (buildCounterCategoryItems < 3) {
     o.badgeUrl = "foo";
     o.categoryId = "foo";
     o.name = "foo";
   }
   buildCounterCategoryItems--;
   return o;
 }
 
 checkCategoryItems(api.CategoryItems o) {
   buildCounterCategoryItems++;
   if (buildCounterCategoryItems < 3) {
     unittest.expect(o.badgeUrl, unittest.equals('foo'));
     unittest.expect(o.categoryId, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterCategoryItems--;
 }
 
-buildUnnamed811() {
+buildUnnamed333() {
   var o = new core.List<api.CategoryItems>();
   o.add(buildCategoryItems());
   o.add(buildCategoryItems());
   return o;
 }
 
-checkUnnamed811(core.List<api.CategoryItems> o) {
+checkUnnamed333(core.List<api.CategoryItems> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCategoryItems(o[0]);
   checkCategoryItems(o[1]);
 }
 
 core.int buildCounterCategory = 0;
 buildCategory() {
   var o = new api.Category();
   buildCounterCategory++;
   if (buildCounterCategory < 3) {
-    o.items = buildUnnamed811();
+    o.items = buildUnnamed333();
     o.kind = "foo";
   }
   buildCounterCategory--;
   return o;
 }
 
 checkCategory(api.Category o) {
   buildCounterCategory++;
   if (buildCounterCategory < 3) {
-    checkUnnamed811(o.items);
+    checkUnnamed333(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterCategory--;
 }
 
 core.int buildCounterConcurrentAccessRestriction = 0;
 buildConcurrentAccessRestriction() {
   var o = new api.ConcurrentAccessRestriction();
   buildCounterConcurrentAccessRestriction++;
   if (buildCounterConcurrentAccessRestriction < 3) {
@@ skipping 106 matching lines @@
 
 checkDictlayerdataDictWordsDerivatives(api.DictlayerdataDictWordsDerivatives o) {
   buildCounterDictlayerdataDictWordsDerivatives++;
   if (buildCounterDictlayerdataDictWordsDerivatives < 3) {
     checkDictlayerdataDictWordsDerivativesSource(o.source);
     unittest.expect(o.text, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsDerivatives--;
 }
 
-buildUnnamed812() {
+buildUnnamed334() {
   var o = new core.List<api.DictlayerdataDictWordsDerivatives>();
   o.add(buildDictlayerdataDictWordsDerivatives());
   o.add(buildDictlayerdataDictWordsDerivatives());
   return o;
 }
 
-checkUnnamed812(core.List<api.DictlayerdataDictWordsDerivatives> o) {
+checkUnnamed334(core.List<api.DictlayerdataDictWordsDerivatives> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsDerivatives(o[0]);
   checkDictlayerdataDictWordsDerivatives(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsExamplesSource = 0;
 buildDictlayerdataDictWordsExamplesSource() {
   var o = new api.DictlayerdataDictWordsExamplesSource();
   buildCounterDictlayerdataDictWordsExamplesSource++;
   if (buildCounterDictlayerdataDictWordsExamplesSource < 3) {
@@ skipping 27 matching lines @@
 
 checkDictlayerdataDictWordsExamples(api.DictlayerdataDictWordsExamples o) {
   buildCounterDictlayerdataDictWordsExamples++;
   if (buildCounterDictlayerdataDictWordsExamples < 3) {
     checkDictlayerdataDictWordsExamplesSource(o.source);
     unittest.expect(o.text, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsExamples--;
 }
 
-buildUnnamed813() {
+buildUnnamed335() {
   var o = new core.List<api.DictlayerdataDictWordsExamples>();
   o.add(buildDictlayerdataDictWordsExamples());
   o.add(buildDictlayerdataDictWordsExamples());
   return o;
 }
 
-checkUnnamed813(core.List<api.DictlayerdataDictWordsExamples> o) {
+checkUnnamed335(core.List<api.DictlayerdataDictWordsExamples> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsExamples(o[0]);
   checkDictlayerdataDictWordsExamples(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSensesConjugations = 0;
 buildDictlayerdataDictWordsSensesConjugations() {
   var o = new api.DictlayerdataDictWordsSensesConjugations();
   buildCounterDictlayerdataDictWordsSensesConjugations++;
   if (buildCounterDictlayerdataDictWordsSensesConjugations < 3) {
     o.type = "foo";
     o.value = "foo";
   }
   buildCounterDictlayerdataDictWordsSensesConjugations--;
   return o;
 }
 
 checkDictlayerdataDictWordsSensesConjugations(api.DictlayerdataDictWordsSensesConjugations o) {
   buildCounterDictlayerdataDictWordsSensesConjugations++;
   if (buildCounterDictlayerdataDictWordsSensesConjugations < 3) {
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.value, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsSensesConjugations--;
 }
 
-buildUnnamed814() {
+buildUnnamed336() {
   var o = new core.List<api.DictlayerdataDictWordsSensesConjugations>();
   o.add(buildDictlayerdataDictWordsSensesConjugations());
   o.add(buildDictlayerdataDictWordsSensesConjugations());
   return o;
 }
 
-checkUnnamed814(core.List<api.DictlayerdataDictWordsSensesConjugations> o) {
+checkUnnamed336(core.List<api.DictlayerdataDictWordsSensesConjugations> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsSensesConjugations(o[0]);
   checkDictlayerdataDictWordsSensesConjugations(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSensesDefinitionsExamplesSource = 0;
 buildDictlayerdataDictWordsSensesDefinitionsExamplesSource() {
   var o = new api.DictlayerdataDictWordsSensesDefinitionsExamplesSource();
   buildCounterDictlayerdataDictWordsSensesDefinitionsExamplesSource++;
   if (buildCounterDictlayerdataDictWordsSensesDefinitionsExamplesSource < 3) {
@@ skipping 27 matching lines @@
 
 checkDictlayerdataDictWordsSensesDefinitionsExamples(api.DictlayerdataDictWordsSensesDefinitionsExamples o) {
   buildCounterDictlayerdataDictWordsSensesDefinitionsExamples++;
   if (buildCounterDictlayerdataDictWordsSensesDefinitionsExamples < 3) {
     checkDictlayerdataDictWordsSensesDefinitionsExamplesSource(o.source);
     unittest.expect(o.text, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsSensesDefinitionsExamples--;
 }
 
-buildUnnamed815() {
+buildUnnamed337() {
   var o = new core.List<api.DictlayerdataDictWordsSensesDefinitionsExamples>();
   o.add(buildDictlayerdataDictWordsSensesDefinitionsExamples());
   o.add(buildDictlayerdataDictWordsSensesDefinitionsExamples());
   return o;
 }
 
-checkUnnamed815(core.List<api.DictlayerdataDictWordsSensesDefinitionsExamples> o) {
+checkUnnamed337(core.List<api.DictlayerdataDictWordsSensesDefinitionsExamples> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsSensesDefinitionsExamples(o[0]);
   checkDictlayerdataDictWordsSensesDefinitionsExamples(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSensesDefinitions = 0;
 buildDictlayerdataDictWordsSensesDefinitions() {
   var o = new api.DictlayerdataDictWordsSensesDefinitions();
   buildCounterDictlayerdataDictWordsSensesDefinitions++;
   if (buildCounterDictlayerdataDictWordsSensesDefinitions < 3) {
     o.definition = "foo";
-    o.examples = buildUnnamed815();
+    o.examples = buildUnnamed337();
   }
   buildCounterDictlayerdataDictWordsSensesDefinitions--;
   return o;
 }
 
 checkDictlayerdataDictWordsSensesDefinitions(api.DictlayerdataDictWordsSensesDefinitions o) {
   buildCounterDictlayerdataDictWordsSensesDefinitions++;
   if (buildCounterDictlayerdataDictWordsSensesDefinitions < 3) {
     unittest.expect(o.definition, unittest.equals('foo'));
-    checkUnnamed815(o.examples);
+    checkUnnamed337(o.examples);
   }
   buildCounterDictlayerdataDictWordsSensesDefinitions--;
 }
 
-buildUnnamed816() {
+buildUnnamed338() {
   var o = new core.List<api.DictlayerdataDictWordsSensesDefinitions>();
   o.add(buildDictlayerdataDictWordsSensesDefinitions());
   o.add(buildDictlayerdataDictWordsSensesDefinitions());
   return o;
 }
 
-checkUnnamed816(core.List<api.DictlayerdataDictWordsSensesDefinitions> o) {
+checkUnnamed338(core.List<api.DictlayerdataDictWordsSensesDefinitions> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsSensesDefinitions(o[0]);
   checkDictlayerdataDictWordsSensesDefinitions(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSensesSource = 0;
 buildDictlayerdataDictWordsSensesSource() {
   var o = new api.DictlayerdataDictWordsSensesSource();
   buildCounterDictlayerdataDictWordsSensesSource++;
   if (buildCounterDictlayerdataDictWordsSensesSource < 3) {
@@ skipping 48 matching lines @@
 
 checkDictlayerdataDictWordsSensesSynonyms(api.DictlayerdataDictWordsSensesSynonyms o) {
   buildCounterDictlayerdataDictWordsSensesSynonyms++;
   if (buildCounterDictlayerdataDictWordsSensesSynonyms < 3) {
     checkDictlayerdataDictWordsSensesSynonymsSource(o.source);
     unittest.expect(o.text, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsSensesSynonyms--;
 }
 
-buildUnnamed817() {
+buildUnnamed339() {
   var o = new core.List<api.DictlayerdataDictWordsSensesSynonyms>();
   o.add(buildDictlayerdataDictWordsSensesSynonyms());
   o.add(buildDictlayerdataDictWordsSensesSynonyms());
   return o;
 }
 
-checkUnnamed817(core.List<api.DictlayerdataDictWordsSensesSynonyms> o) {
+checkUnnamed339(core.List<api.DictlayerdataDictWordsSensesSynonyms> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsSensesSynonyms(o[0]);
   checkDictlayerdataDictWordsSensesSynonyms(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSenses = 0;
 buildDictlayerdataDictWordsSenses() {
   var o = new api.DictlayerdataDictWordsSenses();
   buildCounterDictlayerdataDictWordsSenses++;
   if (buildCounterDictlayerdataDictWordsSenses < 3) {
-    o.conjugations = buildUnnamed814();
-    o.definitions = buildUnnamed816();
+    o.conjugations = buildUnnamed336();
+    o.definitions = buildUnnamed338();
     o.partOfSpeech = "foo";
     o.pronunciation = "foo";
     o.pronunciationUrl = "foo";
     o.source = buildDictlayerdataDictWordsSensesSource();
     o.syllabification = "foo";
-    o.synonyms = buildUnnamed817();
+    o.synonyms = buildUnnamed339();
   }
   buildCounterDictlayerdataDictWordsSenses--;
   return o;
 }
 
 checkDictlayerdataDictWordsSenses(api.DictlayerdataDictWordsSenses o) {
   buildCounterDictlayerdataDictWordsSenses++;
   if (buildCounterDictlayerdataDictWordsSenses < 3) {
-    checkUnnamed814(o.conjugations);
-    checkUnnamed816(o.definitions);
+    checkUnnamed336(o.conjugations);
+    checkUnnamed338(o.definitions);
     unittest.expect(o.partOfSpeech, unittest.equals('foo'));
     unittest.expect(o.pronunciation, unittest.equals('foo'));
     unittest.expect(o.pronunciationUrl, unittest.equals('foo'));
     checkDictlayerdataDictWordsSensesSource(o.source);
     unittest.expect(o.syllabification, unittest.equals('foo'));
-    checkUnnamed817(o.synonyms);
+    checkUnnamed339(o.synonyms);
   }
   buildCounterDictlayerdataDictWordsSenses--;
 }
 
-buildUnnamed818() {
+buildUnnamed340() {
   var o = new core.List<api.DictlayerdataDictWordsSenses>();
   o.add(buildDictlayerdataDictWordsSenses());
   o.add(buildDictlayerdataDictWordsSenses());
   return o;
 }
 
-checkUnnamed818(core.List<api.DictlayerdataDictWordsSenses> o) {
+checkUnnamed340(core.List<api.DictlayerdataDictWordsSenses> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWordsSenses(o[0]);
   checkDictlayerdataDictWordsSenses(o[1]);
 }
 
 core.int buildCounterDictlayerdataDictWordsSource = 0;
 buildDictlayerdataDictWordsSource() {
   var o = new api.DictlayerdataDictWordsSource();
   buildCounterDictlayerdataDictWordsSource++;
   if (buildCounterDictlayerdataDictWordsSource < 3) {
@@ skipping 11 matching lines @@
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterDictlayerdataDictWordsSource--;
 }
 
 core.int buildCounterDictlayerdataDictWords = 0;
 buildDictlayerdataDictWords() {
   var o = new api.DictlayerdataDictWords();
   buildCounterDictlayerdataDictWords++;
   if (buildCounterDictlayerdataDictWords < 3) {
-    o.derivatives = buildUnnamed812();
-    o.examples = buildUnnamed813();
-    o.senses = buildUnnamed818();
+    o.derivatives = buildUnnamed334();
+    o.examples = buildUnnamed335();
+    o.senses = buildUnnamed340();
     o.source = buildDictlayerdataDictWordsSource();
   }
   buildCounterDictlayerdataDictWords--;
   return o;
 }
 
 checkDictlayerdataDictWords(api.DictlayerdataDictWords o) {
   buildCounterDictlayerdataDictWords++;
   if (buildCounterDictlayerdataDictWords < 3) {
-    checkUnnamed812(o.derivatives);
-    checkUnnamed813(o.examples);
-    checkUnnamed818(o.senses);
+    checkUnnamed334(o.derivatives);
+    checkUnnamed335(o.examples);
+    checkUnnamed340(o.senses);
     checkDictlayerdataDictWordsSource(o.source);
   }
   buildCounterDictlayerdataDictWords--;
 }
 
-buildUnnamed819() {
+buildUnnamed341() {
   var o = new core.List<api.DictlayerdataDictWords>();
   o.add(buildDictlayerdataDictWords());
   o.add(buildDictlayerdataDictWords());
   return o;
 }
 
-checkUnnamed819(core.List<api.DictlayerdataDictWords> o) {
+checkUnnamed341(core.List<api.DictlayerdataDictWords> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDictlayerdataDictWords(o[0]);
   checkDictlayerdataDictWords(o[1]);
 }
 
 core.int buildCounterDictlayerdataDict = 0;
 buildDictlayerdataDict() {
   var o = new api.DictlayerdataDict();
   buildCounterDictlayerdataDict++;
   if (buildCounterDictlayerdataDict < 3) {
     o.source = buildDictlayerdataDictSource();
-    o.words = buildUnnamed819();
+    o.words = buildUnnamed341();
   }
   buildCounterDictlayerdataDict--;
   return o;
 }
 
 checkDictlayerdataDict(api.DictlayerdataDict o) {
   buildCounterDictlayerdataDict++;
   if (buildCounterDictlayerdataDict < 3) {
     checkDictlayerdataDictSource(o.source);
-    checkUnnamed819(o.words);
+    checkUnnamed341(o.words);
   }
   buildCounterDictlayerdataDict--;
 }
 
 core.int buildCounterDictlayerdata = 0;
 buildDictlayerdata() {
   var o = new api.Dictlayerdata();
   buildCounterDictlayerdata++;
   if (buildCounterDictlayerdata < 3) {
     o.common = buildDictlayerdataCommon();
@@ skipping 48 matching lines @@
     unittest.expect(o.nonce, unittest.equals('foo'));
     unittest.expect(o.reasonCode, unittest.equals('foo'));
     unittest.expect(o.restricted, unittest.isTrue);
     unittest.expect(o.signature, unittest.equals('foo'));
     unittest.expect(o.source, unittest.equals('foo'));
     unittest.expect(o.volumeId, unittest.equals('foo'));
   }
   buildCounterDownloadAccessRestriction--;
 }
 
-buildUnnamed820() {
+buildUnnamed342() {
   var o = new core.List<api.DownloadAccessRestriction>();
   o.add(buildDownloadAccessRestriction());
   o.add(buildDownloadAccessRestriction());
   return o;
 }
 
-checkUnnamed820(core.List<api.DownloadAccessRestriction> o) {
+checkUnnamed342(core.List<api.DownloadAccessRestriction> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDownloadAccessRestriction(o[0]);
   checkDownloadAccessRestriction(o[1]);
 }
 
 core.int buildCounterDownloadAccesses = 0;
 buildDownloadAccesses() {
   var o = new api.DownloadAccesses();
   buildCounterDownloadAccesses++;
   if (buildCounterDownloadAccesses < 3) {
-    o.downloadAccessList = buildUnnamed820();
+    o.downloadAccessList = buildUnnamed342();
     o.kind = "foo";
   }
   buildCounterDownloadAccesses--;
   return o;
 }
 
 checkDownloadAccesses(api.DownloadAccesses o) {
   buildCounterDownloadAccesses++;
   if (buildCounterDownloadAccesses < 3) {
-    checkUnnamed820(o.downloadAccessList);
+    checkUnnamed342(o.downloadAccessList);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterDownloadAccesses--;
 }
 
 core.int buildCounterGeolayerdataCommon = 0;
 buildGeolayerdataCommon() {
   var o = new api.GeolayerdataCommon();
   buildCounterGeolayerdataCommon++;
   if (buildCounterGeolayerdataCommon < 3) {
@@ skipping 33 matching lines @@
 
 checkGeolayerdataGeoBoundary(api.GeolayerdataGeoBoundary o) {
   buildCounterGeolayerdataGeoBoundary++;
   if (buildCounterGeolayerdataGeoBoundary < 3) {
     unittest.expect(o.latitude, unittest.equals(42));
     unittest.expect(o.longitude, unittest.equals(42));
   }
   buildCounterGeolayerdataGeoBoundary--;
 }
 
-buildUnnamed821() {
+buildUnnamed343() {
   var o = new core.List<api.GeolayerdataGeoBoundary>();
   o.add(buildGeolayerdataGeoBoundary());
   o.add(buildGeolayerdataGeoBoundary());
   return o;
 }
 
-checkUnnamed821(core.List<api.GeolayerdataGeoBoundary> o) {
+checkUnnamed343(core.List<api.GeolayerdataGeoBoundary> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkGeolayerdataGeoBoundary(o[0]);
   checkGeolayerdataGeoBoundary(o[1]);
 }
 
-buildUnnamed822() {
+buildUnnamed344() {
   var o = new core.List<core.List<api.GeolayerdataGeoBoundary>>();
-  o.add(buildUnnamed821());
-  o.add(buildUnnamed821());
+  o.add(buildUnnamed343());
+  o.add(buildUnnamed343());
   return o;
 }
 
-checkUnnamed822(core.List<core.List<api.GeolayerdataGeoBoundary>> o) {
+checkUnnamed344(core.List<core.List<api.GeolayerdataGeoBoundary>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed821(o[0]);
-  checkUnnamed821(o[1]);
+  checkUnnamed343(o[0]);
+  checkUnnamed343(o[1]);
 }
 
 core.int buildCounterGeolayerdataGeoViewportHi = 0;
 buildGeolayerdataGeoViewportHi() {
   var o = new api.GeolayerdataGeoViewportHi();
   buildCounterGeolayerdataGeoViewportHi++;
   if (buildCounterGeolayerdataGeoViewportHi < 3) {
     o.latitude = 42.0;
     o.longitude = 42.0;
   }
@@ skipping 50 matching lines @@
     checkGeolayerdataGeoViewportLo(o.lo);
   }
   buildCounterGeolayerdataGeoViewport--;
 }
 
 core.int buildCounterGeolayerdataGeo = 0;
 buildGeolayerdataGeo() {
   var o = new api.GeolayerdataGeo();
   buildCounterGeolayerdataGeo++;
   if (buildCounterGeolayerdataGeo < 3) {
-    o.boundary = buildUnnamed822();
+    o.boundary = buildUnnamed344();
     o.cachePolicy = "foo";
     o.countryCode = "foo";
     o.latitude = 42.0;
     o.longitude = 42.0;
     o.mapType = "foo";
     o.viewport = buildGeolayerdataGeoViewport();
     o.zoom = 42;
   }
   buildCounterGeolayerdataGeo--;
   return o;
 }
 
 checkGeolayerdataGeo(api.GeolayerdataGeo o) {
   buildCounterGeolayerdataGeo++;
   if (buildCounterGeolayerdataGeo < 3) {
-    checkUnnamed822(o.boundary);
+    checkUnnamed344(o.boundary);
     unittest.expect(o.cachePolicy, unittest.equals('foo'));
     unittest.expect(o.countryCode, unittest.equals('foo'));
     unittest.expect(o.latitude, unittest.equals(42.0));
     unittest.expect(o.longitude, unittest.equals(42.0));
     unittest.expect(o.mapType, unittest.equals('foo'));
     checkGeolayerdataGeoViewport(o.viewport);
     unittest.expect(o.zoom, unittest.equals(42));
   }
   buildCounterGeolayerdataGeo--;
 }
@@ skipping 14 matching lines @@
 checkGeolayerdata(api.Geolayerdata o) {
   buildCounterGeolayerdata++;
   if (buildCounterGeolayerdata < 3) {
     checkGeolayerdataCommon(o.common);
     checkGeolayerdataGeo(o.geo);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterGeolayerdata--;
 }
 
-buildUnnamed823() {
+buildUnnamed345() {
   var o = new core.List<api.Layersummary>();
   o.add(buildLayersummary());
   o.add(buildLayersummary());
   return o;
 }
 
-checkUnnamed823(core.List<api.Layersummary> o) {
+checkUnnamed345(core.List<api.Layersummary> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLayersummary(o[0]);
   checkLayersummary(o[1]);
 }
 
 core.int buildCounterLayersummaries = 0;
 buildLayersummaries() {
   var o = new api.Layersummaries();
   buildCounterLayersummaries++;
   if (buildCounterLayersummaries < 3) {
-    o.items = buildUnnamed823();
+    o.items = buildUnnamed345();
     o.kind = "foo";
     o.totalItems = 42;
   }
   buildCounterLayersummaries--;
   return o;
 }
 
 checkLayersummaries(api.Layersummaries o) {
   buildCounterLayersummaries++;
   if (buildCounterLayersummaries < 3) {
-    checkUnnamed823(o.items);
+    checkUnnamed345(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterLayersummaries--;
 }
 
-buildUnnamed824() {
+buildUnnamed346() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed824(core.List<core.String> o) {
+checkUnnamed346(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 buildCounterLayersummary = 0;
 buildLayersummary() {
   var o = new api.Layersummary();
   buildCounterLayersummary++;
   if (buildCounterLayersummary < 3) {
     o.annotationCount = 42;
-    o.annotationTypes = buildUnnamed824();
+    o.annotationTypes = buildUnnamed346();
     o.annotationsDataLink = "foo";
     o.annotationsLink = "foo";
     o.contentVersion = "foo";
     o.dataCount = 42;
     o.id = "foo";
     o.kind = "foo";
     o.layerId = "foo";
     o.selfLink = "foo";
     o.updated = core.DateTime.parse("2002-02-27T14:01:02");
     o.volumeAnnotationsVersion = "foo";
     o.volumeId = "foo";
   }
   buildCounterLayersummary--;
   return o;
 }
 
 checkLayersummary(api.Layersummary o) {
   buildCounterLayersummary++;
   if (buildCounterLayersummary < 3) {
     unittest.expect(o.annotationCount, unittest.equals(42));
-    checkUnnamed824(o.annotationTypes);
+    checkUnnamed346(o.annotationTypes);
     unittest.expect(o.annotationsDataLink, unittest.equals('foo'));
     unittest.expect(o.annotationsLink, unittest.equals('foo'));
     unittest.expect(o.contentVersion, unittest.equals('foo'));
     unittest.expect(o.dataCount, unittest.equals(42));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.layerId, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.volumeAnnotationsVersion, unittest.equals('foo'));
@@ skipping 22 matching lines @@
   if (buildCounterMetadataItems < 3) {
     unittest.expect(o.downloadUrl, unittest.equals('foo'));
     unittest.expect(o.encryptedKey, unittest.equals('foo'));
     unittest.expect(o.language, unittest.equals('foo'));
     unittest.expect(o.size, unittest.equals('foo'));
     unittest.expect(o.version, unittest.equals('foo'));
   }
   buildCounterMetadataItems--;
 }
 
-buildUnnamed825() {
+buildUnnamed347() {
   var o = new core.List<api.MetadataItems>();
   o.add(buildMetadataItems());
   o.add(buildMetadataItems());
   return o;
 }
 
-checkUnnamed825(core.List<api.MetadataItems> o) {
+checkUnnamed347(core.List<api.MetadataItems> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetadataItems(o[0]);
   checkMetadataItems(o[1]);
 }
 
 core.int buildCounterMetadata = 0;
 buildMetadata() {
   var o = new api.Metadata();
   buildCounterMetadata++;
   if (buildCounterMetadata < 3) {
-    o.items = buildUnnamed825();
+    o.items = buildUnnamed347();
     o.kind = "foo";
   }
   buildCounterMetadata--;
   return o;
 }
 
 checkMetadata(api.Metadata o) {
   buildCounterMetadata++;
   if (buildCounterMetadata < 3) {
-    checkUnnamed825(o.items);
+    checkUnnamed347(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterMetadata--;
 }
 
 core.int buildCounterOffersItemsItems = 0;
 buildOffersItemsItems() {
   var o = new api.OffersItemsItems();
   buildCounterOffersItemsItems++;
   if (buildCounterOffersItemsItems < 3) {
@@ skipping 14 matching lines @@
     unittest.expect(o.author, unittest.equals('foo'));
     unittest.expect(o.canonicalVolumeLink, unittest.equals('foo'));
     unittest.expect(o.coverUrl, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.volumeId, unittest.equals('foo'));
   }
   buildCounterOffersItemsItems--;
 }
 
-buildUnnamed826() {
+buildUnnamed348() {
   var o = new core.List<api.OffersItemsItems>();
   o.add(buildOffersItemsItems());
   o.add(buildOffersItemsItems());
   return o;
 }
 
-checkUnnamed826(core.List<api.OffersItemsItems> o) {
+checkUnnamed348(core.List<api.OffersItemsItems> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOffersItemsItems(o[0]);
   checkOffersItemsItems(o[1]);
 }
 
 core.int buildCounterOffersItems = 0;
 buildOffersItems() {
   var o = new api.OffersItems();
   buildCounterOffersItems++;
   if (buildCounterOffersItems < 3) {
     o.artUrl = "foo";
     o.gservicesKey = "foo";
     o.id = "foo";
-    o.items = buildUnnamed826();
+    o.items = buildUnnamed348();
   }
   buildCounterOffersItems--;
   return o;
 }
 
 checkOffersItems(api.OffersItems o) {
   buildCounterOffersItems++;
   if (buildCounterOffersItems < 3) {
     unittest.expect(o.artUrl, unittest.equals('foo'));
     unittest.expect(o.gservicesKey, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed826(o.items);
+    checkUnnamed348(o.items);
   }
   buildCounterOffersItems--;
 }
 
-buildUnnamed827() {
+buildUnnamed349() {
   var o = new core.List<api.OffersItems>();
   o.add(buildOffersItems());
   o.add(buildOffersItems());
   return o;
 }
 
-checkUnnamed827(core.List<api.OffersItems> o) {
+checkUnnamed349(core.List<api.OffersItems> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOffersItems(o[0]);
   checkOffersItems(o[1]);
 }
 
 core.int buildCounterOffers = 0;
 buildOffers() {
   var o = new api.Offers();
   buildCounterOffers++;
   if (buildCounterOffers < 3) {
-    o.items = buildUnnamed827();
+    o.items = buildUnnamed349();
     o.kind = "foo";
   }
   buildCounterOffers--;
   return o;
 }
 
 checkOffers(api.Offers o) {
   buildCounterOffers++;
   if (buildCounterOffers < 3) {
-    checkUnnamed827(o.items);
+    checkUnnamed349(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterOffers--;
 }
 
 core.int buildCounterReadingPosition = 0;
 buildReadingPosition() {
   var o = new api.ReadingPosition();
   buildCounterReadingPosition++;
   if (buildCounterReadingPosition < 3) {
@@ skipping 272 matching lines @@
 
 checkVolumeLayerInfoLayers(api.VolumeLayerInfoLayers o) {
   buildCounterVolumeLayerInfoLayers++;
   if (buildCounterVolumeLayerInfoLayers < 3) {
     unittest.expect(o.layerId, unittest.equals('foo'));
     unittest.expect(o.volumeAnnotationsVersion, unittest.equals('foo'));
   }
   buildCounterVolumeLayerInfoLayers--;
 }
 
-buildUnnamed828() {
+buildUnnamed350() {
   var o = new core.List<api.VolumeLayerInfoLayers>();
   o.add(buildVolumeLayerInfoLayers());
   o.add(buildVolumeLayerInfoLayers());
   return o;
 }
 
-checkUnnamed828(core.List<api.VolumeLayerInfoLayers> o) {
+checkUnnamed350(core.List<api.VolumeLayerInfoLayers> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolumeLayerInfoLayers(o[0]);
   checkVolumeLayerInfoLayers(o[1]);
 }
 
 core.int buildCounterVolumeLayerInfo = 0;
 buildVolumeLayerInfo() {
   var o = new api.VolumeLayerInfo();
   buildCounterVolumeLayerInfo++;
   if (buildCounterVolumeLayerInfo < 3) {
-    o.layers = buildUnnamed828();
+    o.layers = buildUnnamed350();
   }
   buildCounterVolumeLayerInfo--;
   return o;
 }
 
 checkVolumeLayerInfo(api.VolumeLayerInfo o) {
   buildCounterVolumeLayerInfo++;
   if (buildCounterVolumeLayerInfo < 3) {
-    checkUnnamed828(o.layers);
+    checkUnnamed350(o.layers);
   }
   buildCounterVolumeLayerInfo--;
 }
 
 core.int buildCounterVolumeRecommendedInfo = 0;
 buildVolumeRecommendedInfo() {
   var o = new api.VolumeRecommendedInfo();
   buildCounterVolumeRecommendedInfo++;
   if (buildCounterVolumeRecommendedInfo < 3) {
     o.explanation = "foo";
@@ skipping 112 matching lines @@
   buildCounterVolumeSaleInfoOffers++;
   if (buildCounterVolumeSaleInfoOffers < 3) {
     unittest.expect(o.finskyOfferType, unittest.equals(42));
     checkVolumeSaleInfoOffersListPrice(o.listPrice);
     checkVolumeSaleInfoOffersRentalDuration(o.rentalDuration);
     checkVolumeSaleInfoOffersRetailPrice(o.retailPrice);
   }
   buildCounterVolumeSaleInfoOffers--;
 }
 
-buildUnnamed829() {
+buildUnnamed351() {
   var o = new core.List<api.VolumeSaleInfoOffers>();
   o.add(buildVolumeSaleInfoOffers());
   o.add(buildVolumeSaleInfoOffers());
   return o;
 }
 
-checkUnnamed829(core.List<api.VolumeSaleInfoOffers> o) {
+checkUnnamed351(core.List<api.VolumeSaleInfoOffers> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolumeSaleInfoOffers(o[0]);
   checkVolumeSaleInfoOffers(o[1]);
 }
 
 core.int buildCounterVolumeSaleInfoRetailPrice = 0;
 buildVolumeSaleInfoRetailPrice() {
   var o = new api.VolumeSaleInfoRetailPrice();
   buildCounterVolumeSaleInfoRetailPrice++;
   if (buildCounterVolumeSaleInfoRetailPrice < 3) {
@@ skipping 15 matching lines @@
 
 core.int buildCounterVolumeSaleInfo = 0;
 buildVolumeSaleInfo() {
   var o = new api.VolumeSaleInfo();
   buildCounterVolumeSaleInfo++;
   if (buildCounterVolumeSaleInfo < 3) {
     o.buyLink = "foo";
     o.country = "foo";
     o.isEbook = true;
     o.listPrice = buildVolumeSaleInfoListPrice();
-    o.offers = buildUnnamed829();
+    o.offers = buildUnnamed351();
     o.onSaleDate = core.DateTime.parse("2002-02-27T14:01:02");
     o.retailPrice = buildVolumeSaleInfoRetailPrice();
     o.saleability = "foo";
   }
   buildCounterVolumeSaleInfo--;
   return o;
 }
 
 checkVolumeSaleInfo(api.VolumeSaleInfo o) {
   buildCounterVolumeSaleInfo++;
   if (buildCounterVolumeSaleInfo < 3) {
     unittest.expect(o.buyLink, unittest.equals('foo'));
     unittest.expect(o.country, unittest.equals('foo'));
     unittest.expect(o.isEbook, unittest.isTrue);
     checkVolumeSaleInfoListPrice(o.listPrice);
-    checkUnnamed829(o.offers);
+    checkUnnamed351(o.offers);
     unittest.expect(o.onSaleDate, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkVolumeSaleInfoRetailPrice(o.retailPrice);
     unittest.expect(o.saleability, unittest.equals('foo'));
   }
   buildCounterVolumeSaleInfo--;
 }
 
 core.int buildCounterVolumeSearchInfo = 0;
 buildVolumeSearchInfo() {
   var o = new api.VolumeSearchInfo();
@@ skipping 110 matching lines @@
     checkReadingPosition(o.readingPosition);
     checkVolumeUserInfoRentalPeriod(o.rentalPeriod);
     unittest.expect(o.rentalState, unittest.equals('foo'));
     checkReview(o.review);
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkVolumeUserInfoUserUploadedVolumeInfo(o.userUploadedVolumeInfo);
   }
   buildCounterVolumeUserInfo--;
 }
 
-buildUnnamed830() {
+buildUnnamed352() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed830(core.List<core.String> o) {
+checkUnnamed352(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'));
 }
 
-buildUnnamed831() {
+buildUnnamed353() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed831(core.List<core.String> o) {
+checkUnnamed353(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 buildCounterVolumeVolumeInfoDimensions = 0;
 buildVolumeVolumeInfoDimensions() {
   var o = new api.VolumeVolumeInfoDimensions();
   buildCounterVolumeVolumeInfoDimensions++;
   if (buildCounterVolumeVolumeInfoDimensions < 3) {
@@ skipping 58 matching lines @@
 
 checkVolumeVolumeInfoIndustryIdentifiers(api.VolumeVolumeInfoIndustryIdentifiers o) {
   buildCounterVolumeVolumeInfoIndustryIdentifiers++;
   if (buildCounterVolumeVolumeInfoIndustryIdentifiers < 3) {
     unittest.expect(o.identifier, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterVolumeVolumeInfoIndustryIdentifiers--;
 }
 
-buildUnnamed832() {
+buildUnnamed354() {
   var o = new core.List<api.VolumeVolumeInfoIndustryIdentifiers>();
   o.add(buildVolumeVolumeInfoIndustryIdentifiers());
   o.add(buildVolumeVolumeInfoIndustryIdentifiers());
   return o;
 }
 
-checkUnnamed832(core.List<api.VolumeVolumeInfoIndustryIdentifiers> o) {
+checkUnnamed354(core.List<api.VolumeVolumeInfoIndustryIdentifiers> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolumeVolumeInfoIndustryIdentifiers(o[0]);
   checkVolumeVolumeInfoIndustryIdentifiers(o[1]);
 }
 
 core.int buildCounterVolumeVolumeInfo = 0;
 buildVolumeVolumeInfo() {
   var o = new api.VolumeVolumeInfo();
   buildCounterVolumeVolumeInfo++;
   if (buildCounterVolumeVolumeInfo < 3) {
-    o.authors = buildUnnamed830();
+    o.authors = buildUnnamed352();
     o.averageRating = 42.0;
     o.canonicalVolumeLink = "foo";
-    o.categories = buildUnnamed831();
+    o.categories = buildUnnamed353();
     o.contentVersion = "foo";
     o.description = "foo";
     o.dimensions = buildVolumeVolumeInfoDimensions();
     o.imageLinks = buildVolumeVolumeInfoImageLinks();
-    o.industryIdentifiers = buildUnnamed832();
+    o.industryIdentifiers = buildUnnamed354();
     o.infoLink = "foo";
     o.language = "foo";
     o.mainCategory = "foo";
     o.pageCount = 42;
     o.previewLink = "foo";
     o.printType = "foo";
     o.printedPageCount = 42;
     o.publishedDate = "foo";
     o.publisher = "foo";
     o.ratingsCount = 42;
     o.readingModes = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
     o.samplePageCount = 42;
     o.subtitle = "foo";
     o.title = "foo";
   }
   buildCounterVolumeVolumeInfo--;
   return o;
 }
 
 checkVolumeVolumeInfo(api.VolumeVolumeInfo o) {
   buildCounterVolumeVolumeInfo++;
   if (buildCounterVolumeVolumeInfo < 3) {
-    checkUnnamed830(o.authors);
+    checkUnnamed352(o.authors);
     unittest.expect(o.averageRating, unittest.equals(42.0));
     unittest.expect(o.canonicalVolumeLink, unittest.equals('foo'));
-    checkUnnamed831(o.categories);
+    checkUnnamed353(o.categories);
     unittest.expect(o.contentVersion, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkVolumeVolumeInfoDimensions(o.dimensions);
     checkVolumeVolumeInfoImageLinks(o.imageLinks);
-    checkUnnamed832(o.industryIdentifiers);
+    checkUnnamed354(o.industryIdentifiers);
     unittest.expect(o.infoLink, unittest.equals('foo'));
     unittest.expect(o.language, unittest.equals('foo'));
     unittest.expect(o.mainCategory, unittest.equals('foo'));
     unittest.expect(o.pageCount, unittest.equals(42));
     unittest.expect(o.previewLink, unittest.equals('foo'));
     unittest.expect(o.printType, unittest.equals('foo'));
     unittest.expect(o.printedPageCount, unittest.equals(42));
     unittest.expect(o.publishedDate, unittest.equals('foo'));
     unittest.expect(o.publisher, unittest.equals('foo'));
     unittest.expect(o.ratingsCount, unittest.equals(42));
@@ skipping 37 matching lines @@
     checkVolumeRecommendedInfo(o.recommendedInfo);
     checkVolumeSaleInfo(o.saleInfo);
     checkVolumeSearchInfo(o.searchInfo);
     unittest.expect(o.selfLink, unittest.equals('foo'));
     checkVolumeUserInfo(o.userInfo);
     checkVolumeVolumeInfo(o.volumeInfo);
   }
   buildCounterVolume--;
 }
 
-buildUnnamed833() {
+buildUnnamed355() {
   var o = new core.List<api.Volume>();
   o.add(buildVolume());
   o.add(buildVolume());
   return o;
 }
 
-checkUnnamed833(core.List<api.Volume> o) {
+checkUnnamed355(core.List<api.Volume> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolume(o[0]);
   checkVolume(o[1]);
 }
 
 core.int buildCounterVolume2 = 0;
 buildVolume2() {
   var o = new api.Volume2();
   buildCounterVolume2++;
   if (buildCounterVolume2 < 3) {
-    o.items = buildUnnamed833();
+    o.items = buildUnnamed355();
     o.kind = "foo";
     o.nextPageToken = "foo";
   }
   buildCounterVolume2--;
   return o;
 }
 
 checkVolume2(api.Volume2 o) {
   buildCounterVolume2++;
   if (buildCounterVolume2 < 3) {
-    checkUnnamed833(o.items);
+    checkUnnamed355(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterVolume2--;
 }
 
 core.int buildCounterVolumeannotationContentRanges = 0;
 buildVolumeannotationContentRanges() {
   var o = new api.VolumeannotationContentRanges();
   buildCounterVolumeannotationContentRanges++;
@@ skipping 11 matching lines @@
   buildCounterVolumeannotationContentRanges++;
   if (buildCounterVolumeannotationContentRanges < 3) {
     checkBooksAnnotationsRange(o.cfiRange);
     unittest.expect(o.contentVersion, unittest.equals('foo'));
     checkBooksAnnotationsRange(o.gbImageRange);
     checkBooksAnnotationsRange(o.gbTextRange);
   }
   buildCounterVolumeannotationContentRanges--;
 }
 
-buildUnnamed834() {
+buildUnnamed356() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed834(core.List<core.String> o) {
+checkUnnamed356(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 buildCounterVolumeannotation = 0;
 buildVolumeannotation() {
   var o = new api.Volumeannotation();
   buildCounterVolumeannotation++;
   if (buildCounterVolumeannotation < 3) {
     o.annotationDataId = "foo";
     o.annotationDataLink = "foo";
     o.annotationType = "foo";
     o.contentRanges = buildVolumeannotationContentRanges();
     o.data = "foo";
     o.deleted = true;
     o.id = "foo";
     o.kind = "foo";
     o.layerId = "foo";
-    o.pageIds = buildUnnamed834();
+    o.pageIds = buildUnnamed356();
     o.selectedText = "foo";
     o.selfLink = "foo";
     o.updated = core.DateTime.parse("2002-02-27T14:01:02");
     o.volumeId = "foo";
   }
   buildCounterVolumeannotation--;
   return o;
 }
 
 checkVolumeannotation(api.Volumeannotation o) {
   buildCounterVolumeannotation++;
   if (buildCounterVolumeannotation < 3) {
     unittest.expect(o.annotationDataId, unittest.equals('foo'));
     unittest.expect(o.annotationDataLink, unittest.equals('foo'));
     unittest.expect(o.annotationType, unittest.equals('foo'));
     checkVolumeannotationContentRanges(o.contentRanges);
     unittest.expect(o.data, unittest.equals('foo'));
     unittest.expect(o.deleted, unittest.isTrue);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.layerId, unittest.equals('foo'));
-    checkUnnamed834(o.pageIds);
+    checkUnnamed356(o.pageIds);
     unittest.expect(o.selectedText, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.volumeId, unittest.equals('foo'));
   }
   buildCounterVolumeannotation--;
 }
 
-buildUnnamed835() {
+buildUnnamed357() {
   var o = new core.List<api.Volumeannotation>();
   o.add(buildVolumeannotation());
   o.add(buildVolumeannotation());
   return o;
 }
 
-checkUnnamed835(core.List<api.Volumeannotation> o) {
+checkUnnamed357(core.List<api.Volumeannotation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolumeannotation(o[0]);
   checkVolumeannotation(o[1]);
 }
 
 core.int buildCounterVolumeannotations = 0;
 buildVolumeannotations() {
   var o = new api.Volumeannotations();
   buildCounterVolumeannotations++;
   if (buildCounterVolumeannotations < 3) {
-    o.items = buildUnnamed835();
+    o.items = buildUnnamed357();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.totalItems = 42;
     o.version = "foo";
   }
   buildCounterVolumeannotations--;
   return o;
 }
 
 checkVolumeannotations(api.Volumeannotations o) {
   buildCounterVolumeannotations++;
   if (buildCounterVolumeannotations < 3) {
-    checkUnnamed835(o.items);
+    checkUnnamed357(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
     unittest.expect(o.version, unittest.equals('foo'));
   }
   buildCounterVolumeannotations--;
 }
 
-buildUnnamed836() {
+buildUnnamed358() {
   var o = new core.List<api.Volume>();
   o.add(buildVolume());
   o.add(buildVolume());
   return o;
 }
 
-checkUnnamed836(core.List<api.Volume> o) {
+checkUnnamed358(core.List<api.Volume> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVolume(o[0]);
   checkVolume(o[1]);
 }
 
 core.int buildCounterVolumes = 0;
 buildVolumes() {
   var o = new api.Volumes();
   buildCounterVolumes++;
   if (buildCounterVolumes < 3) {
-    o.items = buildUnnamed836();
+    o.items = buildUnnamed358();
     o.kind = "foo";
     o.totalItems = 42;
   }
   buildCounterVolumes--;
   return o;
 }
 
 checkVolumes(api.Volumes o) {
   buildCounterVolumes++;
   if (buildCounterVolumes < 3) {
-    checkUnnamed836(o.items);
+    checkUnnamed358(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.totalItems, unittest.equals(42));
   }
   buildCounterVolumes--;
 }
 
-buildUnnamed837() {
+buildUnnamed359() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed837(core.List<core.String> o) {
+checkUnnamed359(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'));
 }
 
-buildUnnamed838() {
+buildUnnamed360() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed838(core.List<core.String> o) {
+checkUnnamed360(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'));
 }
 
-buildUnnamed839() {
+buildUnnamed361() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed839(core.List<core.String> o) {
+checkUnnamed361(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'));
 }
 
-buildUnnamed840() {
+buildUnnamed362() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed840(core.List<core.String> o) {
+checkUnnamed362(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'));
 }
 
-buildUnnamed841() {
+buildUnnamed363() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed841(core.List<core.String> o) {
+checkUnnamed363(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'));
 }
 
-buildUnnamed842() {
+buildUnnamed364() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed842(core.List<core.String> o) {
+checkUnnamed364(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'));
 }
 
-buildUnnamed843() {
+buildUnnamed365() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed843(core.List<core.String> o) {
+checkUnnamed365(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'));
 }
 
-buildUnnamed844() {
+buildUnnamed366() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed844(core.List<core.String> o) {
+checkUnnamed366(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'));
 }
 
-buildUnnamed845() {
+buildUnnamed367() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed845(core.List<core.String> o) {
+checkUnnamed367(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'));
 }
 
-buildUnnamed846() {
+buildUnnamed368() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed846(core.List<core.String> o) {
+checkUnnamed368(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'));
 }
 
-buildUnnamed847() {
+buildUnnamed369() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed847(core.List<core.String> o) {
+checkUnnamed369(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'));
-}
-
-buildUnnamed848() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed848(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-AnnotationClientVersionRanges", () {
     unittest.test("to-json--from-json", () {
       var o = buildAnnotationClientVersionRanges();
       var od = new api.AnnotationClientVersionRanges.fromJson(o.toJson());
       checkAnnotationClientVersionRanges(od);
     });
@@ skipping 761 matching lines @@
       var o = buildVolumes();
       var od = new api.Volumes.fromJson(o.toJson());
       checkVolumes(od);
     });
   });
 
 
   unittest.group("resource-BookshelvesResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BookshelvesResourceApi res = new api.BooksApi(mock).bookshelves;
       var arg_userId = "foo";
       var arg_shelf = "foo";
       var arg_source = "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["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBookshelf());
-        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_shelf, source: arg_source).then(unittest.expectAsync(((api.Bookshelf response) {
         checkBookshelf(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BookshelvesResourceApi res = new api.BooksApi(mock).bookshelves;
       var arg_userId = "foo";
       var arg_source = "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 25 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBookshelves());
-        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, source: arg_source).then(unittest.expectAsync(((api.Bookshelves response) {
         checkBookshelves(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-BookshelvesVolumesResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.BookshelvesVolumesResourceApi res = new api.BooksApi(mock).bookshelves.volumes;
       var arg_userId = "foo";
       var arg_shelf = "foo";
       var arg_maxResults = 42;
       var arg_showPreorders = true;
       var arg_source = "foo";
       var arg_startIndex = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 39 matching lines @@
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["showPreorders"].first, unittest.equals("$arg_showPreorders"));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.equals(arg_startIndex));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        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_shelf, maxResults: arg_maxResults, showPreorders: arg_showPreorders, source: arg_source, startIndex: arg_startIndex).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-CloudloadingResourceApi", () {
     unittest.test("method--addBook", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CloudloadingResourceApi res = new api.BooksApi(mock).cloudloading;
       var arg_driveDocumentId = "foo";
       var arg_mimeType = "foo";
       var arg_name = "foo";
       var arg_uploadClientToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 23 matching lines @@
         unittest.expect(queryMap["drive_document_id"].first, unittest.equals(arg_driveDocumentId));
         unittest.expect(queryMap["mime_type"].first, unittest.equals(arg_mimeType));
         unittest.expect(queryMap["name"].first, unittest.equals(arg_name));
         unittest.expect(queryMap["upload_client_token"].first, unittest.equals(arg_uploadClientToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBooksCloudloadingResource());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.addBook(driveDocumentId: arg_driveDocumentId, mimeType: arg_mimeType, name: arg_name, uploadClientToken: arg_uploadClientToken).then(unittest.expectAsync(((api.BooksCloudloadingResource response) {
         checkBooksCloudloadingResource(response);
       })));
     });
 
     unittest.test("method--deleteBook", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CloudloadingResourceApi res = new api.BooksApi(mock).cloudloading;
       var arg_volumeId = "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 + 9), unittest.equals("books/v1/"));
@@ skipping 17 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["volumeId"].first, unittest.equals(arg_volumeId));
 
 
         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.deleteBook(arg_volumeId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--updateBook", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.CloudloadingResourceApi res = new api.BooksApi(mock).cloudloading;
       var arg_request = buildBooksCloudloadingResource();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.BooksCloudloadingResource.fromJson(json);
         checkBooksCloudloadingResource(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ 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(buildBooksCloudloadingResource());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.updateBook(arg_request).then(unittest.expectAsync(((api.BooksCloudloadingResource response) {
         checkBooksCloudloadingResource(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-DictionaryResourceApi", () {
     unittest.test("method--listOfflineMetadata", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.DictionaryResourceApi res = new api.BooksApi(mock).dictionary;
       var arg_cpksver = "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 + 9), unittest.equals("books/v1/"));
@@ skipping 17 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["cpksver"].first, unittest.equals(arg_cpksver));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildMetadata());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listOfflineMetadata(arg_cpksver).then(unittest.expectAsync(((api.Metadata response) {
         checkMetadata(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-LayersResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersResourceApi res = new api.BooksApi(mock).layers;
       var arg_volumeId = "foo";
       var arg_summaryId = "foo";
       var arg_contentVersion = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 31 matching lines @@
           }
         }
         unittest.expect(queryMap["contentVersion"].first, unittest.equals(arg_contentVersion));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLayersummary());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_volumeId, arg_summaryId, contentVersion: arg_contentVersion, source: arg_source).then(unittest.expectAsync(((api.Layersummary response) {
         checkLayersummary(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersResourceApi res = new api.BooksApi(mock).layers;
       var arg_volumeId = "foo";
       var arg_contentVersion = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 31 matching lines @@
         unittest.expect(queryMap["contentVersion"].first, unittest.equals(arg_contentVersion));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLayersummaries());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_volumeId, contentVersion: arg_contentVersion, maxResults: arg_maxResults, pageToken: arg_pageToken, source: arg_source).then(unittest.expectAsync(((api.Layersummaries response) {
         checkLayersummaries(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-LayersAnnotationDataResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersAnnotationDataResourceApi res = new api.BooksApi(mock).layers.annotationData;
       var arg_volumeId = "foo";
       var arg_layerId = "foo";
       var arg_annotationDataId = "foo";
       var arg_contentVersion = "foo";
       var arg_allowWebDefinitions = true;
       var arg_h = 42;
       var arg_locale = "foo";
       var arg_scale = 42;
       var arg_source = "foo";
@@ skipping 49 matching lines @@
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(core.int.parse(queryMap["scale"].first), unittest.equals(arg_scale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["w"].first), unittest.equals(arg_w));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotationdata());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_volumeId, arg_layerId, arg_annotationDataId, arg_contentVersion, allowWebDefinitions: arg_allowWebDefinitions, h: arg_h, locale: arg_locale, scale: arg_scale, source: arg_source, w: arg_w).then(unittest.expectAsync(((api.Annotationdata response) {
         checkAnnotationdata(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersAnnotationDataResourceApi res = new api.BooksApi(mock).layers.annotationData;
       var arg_volumeId = "foo";
       var arg_layerId = "foo";
       var arg_contentVersion = "foo";
-      var arg_annotationDataId = buildUnnamed837();
+      var arg_annotationDataId = buildUnnamed359();
       var arg_h = 42;
       var arg_locale = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_scale = 42;
       var arg_source = "foo";
       var arg_updatedMax = "foo";
       var arg_updatedMin = "foo";
       var arg_w = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 48 matching lines @@
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(queryMap["updatedMax"].first, unittest.equals(arg_updatedMax));
         unittest.expect(queryMap["updatedMin"].first, unittest.equals(arg_updatedMin));
         unittest.expect(core.int.parse(queryMap["w"].first), unittest.equals(arg_w));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotationsdata());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_volumeId, arg_layerId, arg_contentVersion, annotationDataId: arg_annotationDataId, h: arg_h, locale: arg_locale, maxResults: arg_maxResults, pageToken: arg_pageToken, scale: arg_scale, source: arg_source, updatedMax: arg_updatedMax, updatedMin: arg_updatedMin, w: arg_w).then(unittest.expectAsync(((api.Annotationsdata response) {
         checkAnnotationsdata(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-LayersVolumeAnnotationsResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersVolumeAnnotationsResourceApi res = new api.BooksApi(mock).layers.volumeAnnotations;
       var arg_volumeId = "foo";
       var arg_layerId = "foo";
       var arg_annotationId = "foo";
       var arg_locale = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 39 matching lines @@
           }
         }
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumeannotation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_volumeId, arg_layerId, arg_annotationId, locale: arg_locale, source: arg_source).then(unittest.expectAsync(((api.Volumeannotation response) {
         checkVolumeannotation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.LayersVolumeAnnotationsResourceApi res = new api.BooksApi(mock).layers.volumeAnnotations;
       var arg_volumeId = "foo";
       var arg_layerId = "foo";
       var arg_contentVersion = "foo";
       var arg_endOffset = "foo";
       var arg_endPosition = "foo";
       var arg_locale = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_showDeleted = true;
@@ skipping 53 matching lines @@
         unittest.expect(queryMap["startPosition"].first, unittest.equals(arg_startPosition));
         unittest.expect(queryMap["updatedMax"].first, unittest.equals(arg_updatedMax));
         unittest.expect(queryMap["updatedMin"].first, unittest.equals(arg_updatedMin));
         unittest.expect(queryMap["volumeAnnotationsVersion"].first, unittest.equals(arg_volumeAnnotationsVersion));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumeannotations());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_volumeId, arg_layerId, arg_contentVersion, endOffset: arg_endOffset, endPosition: arg_endPosition, locale: arg_locale, maxResults: arg_maxResults, pageToken: arg_pageToken, showDeleted: arg_showDeleted, source: arg_source, startOffset: arg_startOffset, startPosition: arg_startPosition, updatedMax: arg_updatedMax, updatedMin: arg_updatedMin, volumeAnnotationsVersion: arg_volumeAnnotationsVersion).then(unittest.expectAsync(((api.Volumeannotations response) {
         checkVolumeannotations(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-MyconfigResourceApi", () {
     unittest.test("method--getUserSettings", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MyconfigResourceApi res = new api.BooksApi(mock).myconfig;
       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 + 9), unittest.equals("books/v1/"));
         pathOffset += 9;
@@ skipping 15 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(buildUsersettings());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getUserSettings().then(unittest.expectAsync(((api.Usersettings response) {
         checkUsersettings(response);
       })));
     });
 
     unittest.test("method--releaseDownloadAccess", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MyconfigResourceApi res = new api.BooksApi(mock).myconfig;
-      var arg_volumeIds = buildUnnamed838();
+      var arg_volumeIds = buildUnnamed360();
       var arg_cpksver = "foo";
       var arg_locale = "foo";
       var arg_source = "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 21 matching lines @@
         unittest.expect(queryMap["volumeIds"], unittest.equals(arg_volumeIds));
         unittest.expect(queryMap["cpksver"].first, unittest.equals(arg_cpksver));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildDownloadAccesses());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.releaseDownloadAccess(arg_volumeIds, arg_cpksver, locale: arg_locale, source: arg_source).then(unittest.expectAsync(((api.DownloadAccesses response) {
         checkDownloadAccesses(response);
       })));
     });
 
     unittest.test("method--requestAccess", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MyconfigResourceApi res = new api.BooksApi(mock).myconfig;
       var arg_source = "foo";
       var arg_volumeId = "foo";
       var arg_nonce = "foo";
       var arg_cpksver = "foo";
       var arg_licenseTypes = "foo";
       var arg_locale = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 27 matching lines @@
         unittest.expect(queryMap["nonce"].first, unittest.equals(arg_nonce));
         unittest.expect(queryMap["cpksver"].first, unittest.equals(arg_cpksver));
         unittest.expect(queryMap["licenseTypes"].first, unittest.equals(arg_licenseTypes));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildRequestAccess());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.requestAccess(arg_source, arg_volumeId, arg_nonce, arg_cpksver, licenseTypes: arg_licenseTypes, locale: arg_locale).then(unittest.expectAsync(((api.RequestAccess response) {
         checkRequestAccess(response);
       })));
     });
 
     unittest.test("method--syncVolumeLicenses", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MyconfigResourceApi res = new api.BooksApi(mock).myconfig;
       var arg_source = "foo";
       var arg_nonce = "foo";
       var arg_cpksver = "foo";
-      var arg_features = buildUnnamed839();
+      var arg_features = buildUnnamed361();
       var arg_locale = "foo";
       var arg_showPreorders = true;
-      var arg_volumeIds = buildUnnamed840();
+      var arg_volumeIds = buildUnnamed362();
       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 + 9), unittest.equals("books/v1/"));
         pathOffset += 9;
         unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.equals("myconfig/syncVolumeLicenses"));
@@ skipping 21 matching lines @@
         unittest.expect(queryMap["features"], unittest.equals(arg_features));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["showPreorders"].first, unittest.equals("$arg_showPreorders"));
         unittest.expect(queryMap["volumeIds"], unittest.equals(arg_volumeIds));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.syncVolumeLicenses(arg_source, arg_nonce, arg_cpksver, features: arg_features, locale: arg_locale, showPreorders: arg_showPreorders, volumeIds: arg_volumeIds).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
     unittest.test("method--updateUserSettings", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MyconfigResourceApi res = new api.BooksApi(mock).myconfig;
       var arg_request = buildUsersettings();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Usersettings.fromJson(json);
         checkUsersettings(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ 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(buildUsersettings());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.updateUserSettings(arg_request).then(unittest.expectAsync(((api.Usersettings response) {
         checkUsersettings(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-MylibraryAnnotationsResourceApi", () {
     unittest.test("method--delete", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
       var arg_annotationId = "foo";
       var arg_source = "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 21 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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_annotationId, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
-    unittest.test("method--get", () {
-
-      var mock = new common_test.HttpServerMock();
-      api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
-      var arg_annotationId = "foo";
-      var arg_source = "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 + 9), unittest.equals("books/v1/"));
-        pathOffset += 9;
-        unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.equals("mylibrary/annotations/"));
-        pathOffset += 22;
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
-        pathOffset = path.length;
-        unittest.expect(subPart, unittest.equals("$arg_annotationId"));
-
-        var query = (req.url).query;
-        var queryOffset = 0;
-        var queryMap = {};
-        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
-        parseBool(n) {
-          if (n == "true") return true;
-          if (n == "false") return false;
-          if (n == null) return null;
-          throw new core.ArgumentError("Invalid boolean: $n");
-        }
-        if (query.length > 0) {
-          for (var part in query.split("&")) {
-            var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
-          }
-        }
-        unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
-
-
-        var h = {
-          "content-type" : "application/json; charset=utf-8",
-        };
-        var resp = convert.JSON.encode(buildAnnotation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
-      }), true);
-      res.get(arg_annotationId, source: arg_source).then(unittest.expectAsync(((api.Annotation response) {
-        checkAnnotation(response);
-      })));
-    });
-
     unittest.test("method--insert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
       var arg_request = buildAnnotation();
       var arg_country = "foo";
       var arg_showOnlySummaryInResponse = true;
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Annotation.fromJson(json);
         checkAnnotation(obj);
 
         var path = (req.url).path;
@@ skipping 25 matching lines @@
         }
         unittest.expect(queryMap["country"].first, unittest.equals(arg_country));
         unittest.expect(queryMap["showOnlySummaryInResponse"].first, unittest.equals("$arg_showOnlySummaryInResponse"));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotation());
-        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, country: arg_country, showOnlySummaryInResponse: arg_showOnlySummaryInResponse, source: arg_source).then(unittest.expectAsync(((api.Annotation response) {
         checkAnnotation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
       var arg_contentVersion = "foo";
       var arg_layerId = "foo";
-      var arg_layerIds = buildUnnamed841();
+      var arg_layerIds = buildUnnamed363();
       var arg_maxResults = 42;
-      var arg_pageIds = buildUnnamed842();
       var arg_pageToken = "foo";
       var arg_showDeleted = true;
       var arg_source = "foo";
       var arg_updatedMax = "foo";
       var arg_updatedMin = "foo";
       var arg_volumeId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
@@ skipping 18 matching lines @@
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["contentVersion"].first, unittest.equals(arg_contentVersion));
         unittest.expect(queryMap["layerId"].first, unittest.equals(arg_layerId));
         unittest.expect(queryMap["layerIds"], unittest.equals(arg_layerIds));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageIds"], unittest.equals(arg_pageIds));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_showDeleted"));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(queryMap["updatedMax"].first, unittest.equals(arg_updatedMax));
         unittest.expect(queryMap["updatedMin"].first, unittest.equals(arg_updatedMin));
         unittest.expect(queryMap["volumeId"].first, unittest.equals(arg_volumeId));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotations());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(contentVersion: arg_contentVersion, layerId: arg_layerId, layerIds: arg_layerIds, maxResults: arg_maxResults, pageIds: arg_pageIds, pageToken: arg_pageToken, showDeleted: arg_showDeleted, source: arg_source, updatedMax: arg_updatedMax, updatedMin: arg_updatedMin, volumeId: arg_volumeId).then(unittest.expectAsync(((api.Annotations response) {
+      res.list(contentVersion: arg_contentVersion, layerId: arg_layerId, layerIds: arg_layerIds, maxResults: arg_maxResults, pageToken: arg_pageToken, showDeleted: arg_showDeleted, source: arg_source, updatedMax: arg_updatedMax, updatedMin: arg_updatedMin, volumeId: arg_volumeId).then(unittest.expectAsync(((api.Annotations response) {
         checkAnnotations(response);
       })));
     });
 
     unittest.test("method--summary", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
-      var arg_layerIds = buildUnnamed843();
+      var arg_layerIds = buildUnnamed364();
       var arg_volumeId = "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 + 9), unittest.equals("books/v1/"));
         pathOffset += 9;
@@ skipping 17 matching lines @@
           }
         }
         unittest.expect(queryMap["layerIds"], unittest.equals(arg_layerIds));
         unittest.expect(queryMap["volumeId"].first, unittest.equals(arg_volumeId));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotationsSummary());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.summary(arg_layerIds, arg_volumeId).then(unittest.expectAsync(((api.AnnotationsSummary response) {
         checkAnnotationsSummary(response);
       })));
     });
 
     unittest.test("method--update", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryAnnotationsResourceApi res = new api.BooksApi(mock).mylibrary.annotations;
       var arg_request = buildAnnotation();
       var arg_annotationId = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Annotation.fromJson(json);
         checkAnnotation(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 25 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildAnnotation());
-        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_annotationId, source: arg_source).then(unittest.expectAsync(((api.Annotation response) {
         checkAnnotation(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-MylibraryBookshelvesResourceApi", () {
     unittest.test("method--addVolume", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_shelf = "foo";
       var arg_volumeId = "foo";
       var arg_reason = "foo";
       var arg_source = "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["volumeId"].first, unittest.equals(arg_volumeId));
         unittest.expect(queryMap["reason"].first, unittest.equals(arg_reason));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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.addVolume(arg_shelf, arg_volumeId, reason: arg_reason, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--clearVolumes", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_shelf = "foo";
       var arg_source = "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 25 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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.clearVolumes(arg_shelf, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_shelf = "foo";
       var arg_source = "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 21 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBookshelf());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_shelf, source: arg_source).then(unittest.expectAsync(((api.Bookshelf response) {
         checkBookshelf(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_source = "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 + 9), unittest.equals("books/v1/"));
@@ skipping 17 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBookshelves());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(source: arg_source).then(unittest.expectAsync(((api.Bookshelves response) {
         checkBookshelves(response);
       })));
     });
 
     unittest.test("method--moveVolume", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_shelf = "foo";
       var arg_volumeId = "foo";
       var arg_volumePosition = 42;
       var arg_source = "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["volumeId"].first, unittest.equals(arg_volumeId));
         unittest.expect(core.int.parse(queryMap["volumePosition"].first), unittest.equals(arg_volumePosition));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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.moveVolume(arg_shelf, arg_volumeId, arg_volumePosition, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--removeVolume", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves;
       var arg_shelf = "foo";
       var arg_volumeId = "foo";
       var arg_reason = "foo";
       var arg_source = "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["volumeId"].first, unittest.equals(arg_volumeId));
         unittest.expect(queryMap["reason"].first, unittest.equals(arg_reason));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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.removeVolume(arg_shelf, arg_volumeId, reason: arg_reason, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
   });
 
 
   unittest.group("resource-MylibraryBookshelvesVolumesResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryBookshelvesVolumesResourceApi res = new api.BooksApi(mock).mylibrary.bookshelves.volumes;
       var arg_shelf = "foo";
       var arg_country = "foo";
       var arg_maxResults = 42;
       var arg_projection = "foo";
       var arg_q = "foo";
       var arg_showPreorders = true;
       var arg_source = "foo";
       var arg_startIndex = 42;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 37 matching lines @@
         unittest.expect(queryMap["q"].first, unittest.equals(arg_q));
         unittest.expect(queryMap["showPreorders"].first, unittest.equals("$arg_showPreorders"));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.equals(arg_startIndex));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_shelf, country: arg_country, maxResults: arg_maxResults, projection: arg_projection, q: arg_q, showPreorders: arg_showPreorders, source: arg_source, startIndex: arg_startIndex).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-MylibraryReadingpositionsResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryReadingpositionsResourceApi res = new api.BooksApi(mock).mylibrary.readingpositions;
       var arg_volumeId = "foo";
       var arg_contentVersion = "foo";
       var arg_source = "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(queryMap["contentVersion"].first, unittest.equals(arg_contentVersion));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildReadingPosition());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_volumeId, contentVersion: arg_contentVersion, source: arg_source).then(unittest.expectAsync(((api.ReadingPosition response) {
         checkReadingPosition(response);
       })));
     });
 
     unittest.test("method--setPosition", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.MylibraryReadingpositionsResourceApi res = new api.BooksApi(mock).mylibrary.readingpositions;
       var arg_volumeId = "foo";
       var arg_timestamp = "foo";
       var arg_position = "foo";
       var arg_action = "foo";
       var arg_contentVersion = "foo";
       var arg_deviceCookie = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
@@ skipping 35 matching lines @@
         unittest.expect(queryMap["action"].first, unittest.equals(arg_action));
         unittest.expect(queryMap["contentVersion"].first, unittest.equals(arg_contentVersion));
         unittest.expect(queryMap["deviceCookie"].first, unittest.equals(arg_deviceCookie));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         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.setPosition(arg_volumeId, arg_timestamp, arg_position, action: arg_action, contentVersion: arg_contentVersion, deviceCookie: arg_deviceCookie, source: arg_source).then(unittest.expectAsync((_) {}));
     });
 
   });
 
 
   unittest.group("resource-OnboardingResourceApi", () {
     unittest.test("method--listCategories", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.OnboardingResourceApi res = new api.BooksApi(mock).onboarding;
       var arg_locale = "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 + 9), unittest.equals("books/v1/"));
@@ skipping 17 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCategory());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listCategories(locale: arg_locale).then(unittest.expectAsync(((api.Category response) {
         checkCategory(response);
       })));
     });
 
     unittest.test("method--listCategoryVolumes", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.OnboardingResourceApi res = new api.BooksApi(mock).onboarding;
-      var arg_categoryId = buildUnnamed844();
+      var arg_categoryId = buildUnnamed365();
       var arg_locale = "foo";
       var arg_pageSize = 42;
       var arg_pageToken = "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 21 matching lines @@
         unittest.expect(queryMap["categoryId"], unittest.equals(arg_categoryId));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolume2());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listCategoryVolumes(categoryId: arg_categoryId, locale: arg_locale, pageSize: arg_pageSize, pageToken: arg_pageToken).then(unittest.expectAsync(((api.Volume2 response) {
         checkVolume2(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-PromoofferResourceApi", () {
     unittest.test("method--accept", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PromoofferResourceApi res = new api.BooksApi(mock).promooffer;
       var arg_androidId = "foo";
       var arg_device = "foo";
       var arg_manufacturer = "foo";
       var arg_model = "foo";
       var arg_offerId = "foo";
       var arg_product = "foo";
       var arg_serial = "foo";
       var arg_volumeId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
@@ skipping 31 matching lines @@
         unittest.expect(queryMap["offerId"].first, unittest.equals(arg_offerId));
         unittest.expect(queryMap["product"].first, unittest.equals(arg_product));
         unittest.expect(queryMap["serial"].first, unittest.equals(arg_serial));
         unittest.expect(queryMap["volumeId"].first, unittest.equals(arg_volumeId));
 
 
         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.accept(androidId: arg_androidId, device: arg_device, manufacturer: arg_manufacturer, model: arg_model, offerId: arg_offerId, product: arg_product, serial: arg_serial, volumeId: arg_volumeId).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--dismiss", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PromoofferResourceApi res = new api.BooksApi(mock).promooffer;
       var arg_androidId = "foo";
       var arg_device = "foo";
       var arg_manufacturer = "foo";
       var arg_model = "foo";
       var arg_offerId = "foo";
       var arg_product = "foo";
       var arg_serial = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
@@ skipping 29 matching lines @@
         unittest.expect(queryMap["model"].first, unittest.equals(arg_model));
         unittest.expect(queryMap["offerId"].first, unittest.equals(arg_offerId));
         unittest.expect(queryMap["product"].first, unittest.equals(arg_product));
         unittest.expect(queryMap["serial"].first, unittest.equals(arg_serial));
 
 
         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.dismiss(androidId: arg_androidId, device: arg_device, manufacturer: arg_manufacturer, model: arg_model, offerId: arg_offerId, product: arg_product, serial: arg_serial).then(unittest.expectAsync((_) {}));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.PromoofferResourceApi res = new api.BooksApi(mock).promooffer;
       var arg_androidId = "foo";
       var arg_device = "foo";
       var arg_manufacturer = "foo";
       var arg_model = "foo";
       var arg_product = "foo";
       var arg_serial = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 27 matching lines @@
         unittest.expect(queryMap["manufacturer"].first, unittest.equals(arg_manufacturer));
         unittest.expect(queryMap["model"].first, unittest.equals(arg_model));
         unittest.expect(queryMap["product"].first, unittest.equals(arg_product));
         unittest.expect(queryMap["serial"].first, unittest.equals(arg_serial));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOffers());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(androidId: arg_androidId, device: arg_device, manufacturer: arg_manufacturer, model: arg_model, product: arg_product, serial: arg_serial).then(unittest.expectAsync(((api.Offers response) {
         checkOffers(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VolumesResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesResourceApi res = new api.BooksApi(mock).volumes;
       var arg_volumeId = "foo";
       var arg_country = "foo";
       var arg_partner = "foo";
       var arg_projection = "foo";
       var arg_source = "foo";
       var arg_userLibraryConsistentRead = true;
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 29 matching lines @@
         unittest.expect(queryMap["partner"].first, unittest.equals(arg_partner));
         unittest.expect(queryMap["projection"].first, unittest.equals(arg_projection));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(queryMap["user_library_consistent_read"].first, unittest.equals("$arg_userLibraryConsistentRead"));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolume());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_volumeId, country: arg_country, partner: arg_partner, projection: arg_projection, source: arg_source, userLibraryConsistentRead: arg_userLibraryConsistentRead).then(unittest.expectAsync(((api.Volume response) {
         checkVolume(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesResourceApi res = new api.BooksApi(mock).volumes;
       var arg_q = "foo";
       var arg_download = "foo";
       var arg_filter = "foo";
       var arg_langRestrict = "foo";
       var arg_libraryRestrict = "foo";
       var arg_maxResults = 42;
       var arg_orderBy = "foo";
       var arg_partner = "foo";
       var arg_printType = "foo";
@@ skipping 41 matching lines @@
         unittest.expect(queryMap["projection"].first, unittest.equals(arg_projection));
         unittest.expect(queryMap["showPreorders"].first, unittest.equals("$arg_showPreorders"));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.equals(arg_startIndex));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_q, download: arg_download, filter: arg_filter, langRestrict: arg_langRestrict, libraryRestrict: arg_libraryRestrict, maxResults: arg_maxResults, orderBy: arg_orderBy, partner: arg_partner, printType: arg_printType, projection: arg_projection, showPreorders: arg_showPreorders, source: arg_source, startIndex: arg_startIndex).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VolumesAssociatedResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesAssociatedResourceApi res = new api.BooksApi(mock).volumes.associated;
       var arg_volumeId = "foo";
       var arg_association = "foo";
       var arg_locale = "foo";
       var arg_source = "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["association"].first, unittest.equals(arg_association));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_volumeId, association: arg_association, locale: arg_locale, source: arg_source).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VolumesMybooksResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesMybooksResourceApi res = new api.BooksApi(mock).volumes.mybooks;
-      var arg_acquireMethod = buildUnnamed845();
+      var arg_acquireMethod = buildUnnamed366();
       var arg_locale = "foo";
       var arg_maxResults = 42;
-      var arg_processingState = buildUnnamed846();
+      var arg_processingState = buildUnnamed367();
       var arg_source = "foo";
       var arg_startIndex = 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("/"));
         pathOffset += 1;
         unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("books/v1/"));
@@ skipping 22 matching lines @@
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["processingState"], unittest.equals(arg_processingState));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.equals(arg_startIndex));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(acquireMethod: arg_acquireMethod, locale: arg_locale, maxResults: arg_maxResults, processingState: arg_processingState, source: arg_source, startIndex: arg_startIndex).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VolumesRecommendedResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesRecommendedResourceApi res = new api.BooksApi(mock).volumes.recommended;
       var arg_locale = "foo";
       var arg_source = "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["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(locale: arg_locale, source: arg_source).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
     unittest.test("method--rate", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesRecommendedResourceApi res = new api.BooksApi(mock).volumes.recommended;
       var arg_rating = "foo";
       var arg_volumeId = "foo";
       var arg_locale = "foo";
       var arg_source = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 23 matching lines @@
         unittest.expect(queryMap["rating"].first, unittest.equals(arg_rating));
         unittest.expect(queryMap["volumeId"].first, unittest.equals(arg_volumeId));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildBooksVolumesRecommendedRateResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.rate(arg_rating, arg_volumeId, locale: arg_locale, source: arg_source).then(unittest.expectAsync(((api.BooksVolumesRecommendedRateResponse response) {
         checkBooksVolumesRecommendedRateResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-VolumesUseruploadedResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.VolumesUseruploadedResourceApi res = new api.BooksApi(mock).volumes.useruploaded;
       var arg_locale = "foo";
       var arg_maxResults = 42;
-      var arg_processingState = buildUnnamed847();
+      var arg_processingState = buildUnnamed368();
       var arg_source = "foo";
       var arg_startIndex = 42;
-      var arg_volumeId = buildUnnamed848();
+      var arg_volumeId = buildUnnamed369();
       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 + 9), unittest.equals("books/v1/"));
         pathOffset += 9;
         unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.equals("volumes/useruploaded"));
@@ skipping 20 matching lines @@
         unittest.expect(queryMap["processingState"], unittest.equals(arg_processingState));
         unittest.expect(queryMap["source"].first, unittest.equals(arg_source));
         unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.equals(arg_startIndex));
         unittest.expect(queryMap["volumeId"], unittest.equals(arg_volumeId));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVolumes());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(locale: arg_locale, maxResults: arg_maxResults, processingState: arg_processingState, source: arg_source, startIndex: arg_startIndex, volumeId: arg_volumeId).then(unittest.expectAsync(((api.Volumes response) {
         checkVolumes(response);
       })));
     });
 
   });
 
 
 }