Roll of googleapis as of 4/7/2015.

generated/googleapis_beta/test/replicapoolupdater/v1beta1_test.dart

 library googleapis_beta.replicapoolupdater.v1beta1.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_beta/common/common.dart' as common;
-import 'package:googleapis_beta/src/common_internal.dart' as common_internal;
-import '../common/common_internal_test.dart' as common_test;
 
 import 'package:googleapis_beta/replicapoolupdater/v1beta1.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 buildCounterInstanceUpdateErrorErrors = 0;
 buildInstanceUpdateErrorErrors() {
   var o = new api.InstanceUpdateErrorErrors();
   buildCounterInstanceUpdateErrorErrors++;
   if (buildCounterInstanceUpdateErrorErrors < 3) {
     o.code = "foo";
     o.location = "foo";
     o.message = "foo";
   }
   buildCounterInstanceUpdateErrorErrors--;
   return o;
 }
 
 checkInstanceUpdateErrorErrors(api.InstanceUpdateErrorErrors o) {
   buildCounterInstanceUpdateErrorErrors++;
   if (buildCounterInstanceUpdateErrorErrors < 3) {
     unittest.expect(o.code, unittest.equals('foo'));
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterInstanceUpdateErrorErrors--;
 }
 
-buildUnnamed1612() {
+buildUnnamed1744() {
   var o = new core.List<api.InstanceUpdateErrorErrors>();
   o.add(buildInstanceUpdateErrorErrors());
   o.add(buildInstanceUpdateErrorErrors());
   return o;
 }
 
-checkUnnamed1612(core.List<api.InstanceUpdateErrorErrors> o) {
+checkUnnamed1744(core.List<api.InstanceUpdateErrorErrors> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkInstanceUpdateErrorErrors(o[0]);
   checkInstanceUpdateErrorErrors(o[1]);
 }
 
 core.int buildCounterInstanceUpdateError = 0;
 buildInstanceUpdateError() {
   var o = new api.InstanceUpdateError();
   buildCounterInstanceUpdateError++;
   if (buildCounterInstanceUpdateError < 3) {
-    o.errors = buildUnnamed1612();
+    o.errors = buildUnnamed1744();
   }
   buildCounterInstanceUpdateError--;
   return o;
 }
 
 checkInstanceUpdateError(api.InstanceUpdateError o) {
   buildCounterInstanceUpdateError++;
   if (buildCounterInstanceUpdateError < 3) {
-    checkUnnamed1612(o.errors);
+    checkUnnamed1744(o.errors);
   }
   buildCounterInstanceUpdateError--;
 }
 
 core.int buildCounterInstanceUpdate = 0;
 buildInstanceUpdate() {
   var o = new api.InstanceUpdate();
   buildCounterInstanceUpdate++;
   if (buildCounterInstanceUpdate < 3) {
     o.error = buildInstanceUpdateError();
     o.instance = "foo";
     o.status = "foo";
   }
   buildCounterInstanceUpdate--;
   return o;
 }
 
 checkInstanceUpdate(api.InstanceUpdate o) {
   buildCounterInstanceUpdate++;
   if (buildCounterInstanceUpdate < 3) {
     checkInstanceUpdateError(o.error);
     unittest.expect(o.instance, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
   }
   buildCounterInstanceUpdate--;
 }
 
-buildUnnamed1613() {
+buildUnnamed1745() {
   var o = new core.List<api.InstanceUpdate>();
   o.add(buildInstanceUpdate());
   o.add(buildInstanceUpdate());
   return o;
 }
 
-checkUnnamed1613(core.List<api.InstanceUpdate> o) {
+checkUnnamed1745(core.List<api.InstanceUpdate> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkInstanceUpdate(o[0]);
   checkInstanceUpdate(o[1]);
 }
 
 core.int buildCounterInstanceUpdateList = 0;
 buildInstanceUpdateList() {
   var o = new api.InstanceUpdateList();
   buildCounterInstanceUpdateList++;
   if (buildCounterInstanceUpdateList < 3) {
-    o.items = buildUnnamed1613();
+    o.items = buildUnnamed1745();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.selfLink = "foo";
   }
   buildCounterInstanceUpdateList--;
   return o;
 }
 
 checkInstanceUpdateList(api.InstanceUpdateList o) {
   buildCounterInstanceUpdateList++;
   if (buildCounterInstanceUpdateList < 3) {
-    checkUnnamed1613(o.items);
+    checkUnnamed1745(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
   }
   buildCounterInstanceUpdateList--;
 }
 
 core.int buildCounterOperationErrorErrors = 0;
 buildOperationErrorErrors() {
   var o = new api.OperationErrorErrors();
@@ skipping 10 matching lines @@
 checkOperationErrorErrors(api.OperationErrorErrors o) {
   buildCounterOperationErrorErrors++;
   if (buildCounterOperationErrorErrors < 3) {
     unittest.expect(o.code, unittest.equals('foo'));
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterOperationErrorErrors--;
 }
 
-buildUnnamed1614() {
+buildUnnamed1746() {
   var o = new core.List<api.OperationErrorErrors>();
   o.add(buildOperationErrorErrors());
   o.add(buildOperationErrorErrors());
   return o;
 }
 
-checkUnnamed1614(core.List<api.OperationErrorErrors> o) {
+checkUnnamed1746(core.List<api.OperationErrorErrors> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationErrorErrors(o[0]);
   checkOperationErrorErrors(o[1]);
 }
 
 core.int buildCounterOperationError = 0;
 buildOperationError() {
   var o = new api.OperationError();
   buildCounterOperationError++;
   if (buildCounterOperationError < 3) {
-    o.errors = buildUnnamed1614();
+    o.errors = buildUnnamed1746();
   }
   buildCounterOperationError--;
   return o;
 }
 
 checkOperationError(api.OperationError o) {
   buildCounterOperationError++;
   if (buildCounterOperationError < 3) {
-    checkUnnamed1614(o.errors);
+    checkUnnamed1746(o.errors);
   }
   buildCounterOperationError--;
 }
 
 core.int buildCounterOperationWarningsData = 0;
 buildOperationWarningsData() {
   var o = new api.OperationWarningsData();
   buildCounterOperationWarningsData++;
   if (buildCounterOperationWarningsData < 3) {
     o.key = "foo";
     o.value = "foo";
   }
   buildCounterOperationWarningsData--;
   return o;
 }
 
 checkOperationWarningsData(api.OperationWarningsData o) {
   buildCounterOperationWarningsData++;
   if (buildCounterOperationWarningsData < 3) {
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.value, unittest.equals('foo'));
   }
   buildCounterOperationWarningsData--;
 }
 
-buildUnnamed1615() {
+buildUnnamed1747() {
   var o = new core.List<api.OperationWarningsData>();
   o.add(buildOperationWarningsData());
   o.add(buildOperationWarningsData());
   return o;
 }
 
-checkUnnamed1615(core.List<api.OperationWarningsData> o) {
+checkUnnamed1747(core.List<api.OperationWarningsData> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationWarningsData(o[0]);
   checkOperationWarningsData(o[1]);
 }
 
 core.int buildCounterOperationWarnings = 0;
 buildOperationWarnings() {
   var o = new api.OperationWarnings();
   buildCounterOperationWarnings++;
   if (buildCounterOperationWarnings < 3) {
     o.code = "foo";
-    o.data = buildUnnamed1615();
+    o.data = buildUnnamed1747();
     o.message = "foo";
   }
   buildCounterOperationWarnings--;
   return o;
 }
 
 checkOperationWarnings(api.OperationWarnings o) {
   buildCounterOperationWarnings++;
   if (buildCounterOperationWarnings < 3) {
     unittest.expect(o.code, unittest.equals('foo'));
-    checkUnnamed1615(o.data);
+    checkUnnamed1747(o.data);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterOperationWarnings--;
 }
 
-buildUnnamed1616() {
+buildUnnamed1748() {
   var o = new core.List<api.OperationWarnings>();
   o.add(buildOperationWarnings());
   o.add(buildOperationWarnings());
   return o;
 }
 
-checkUnnamed1616(core.List<api.OperationWarnings> o) {
+checkUnnamed1748(core.List<api.OperationWarnings> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperationWarnings(o[0]);
   checkOperationWarnings(o[1]);
 }
 
 core.int buildCounterOperation = 0;
 buildOperation() {
   var o = new api.Operation();
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
@@ skipping 10 matching lines @@
     o.operationType = "foo";
     o.progress = 42;
     o.region = "foo";
     o.selfLink = "foo";
     o.startTime = "foo";
     o.status = "foo";
     o.statusMessage = "foo";
     o.targetId = "foo";
     o.targetLink = "foo";
     o.user = "foo";
-    o.warnings = buildUnnamed1616();
+    o.warnings = buildUnnamed1748();
     o.zone = "foo";
   }
   buildCounterOperation--;
   return o;
 }
 
 checkOperation(api.Operation o) {
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     unittest.expect(o.clientOperationId, unittest.equals('foo'));
     unittest.expect(o.creationTimestamp, unittest.equals('foo'));
     unittest.expect(o.endTime, unittest.equals('foo'));
     checkOperationError(o.error);
     unittest.expect(o.httpErrorMessage, unittest.equals('foo'));
     unittest.expect(o.httpErrorStatusCode, unittest.equals(42));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.insertTime, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.operationType, unittest.equals('foo'));
     unittest.expect(o.progress, unittest.equals(42));
     unittest.expect(o.region, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.startTime, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.statusMessage, unittest.equals('foo'));
     unittest.expect(o.targetId, unittest.equals('foo'));
     unittest.expect(o.targetLink, unittest.equals('foo'));
     unittest.expect(o.user, unittest.equals('foo'));
-    checkUnnamed1616(o.warnings);
+    checkUnnamed1748(o.warnings);
     unittest.expect(o.zone, unittest.equals('foo'));
   }
   buildCounterOperation--;
 }
 
 core.int buildCounterRollingUpdateErrorErrors = 0;
 buildRollingUpdateErrorErrors() {
   var o = new api.RollingUpdateErrorErrors();
   buildCounterRollingUpdateErrorErrors++;
   if (buildCounterRollingUpdateErrorErrors < 3) {
     o.code = "foo";
     o.location = "foo";
     o.message = "foo";
   }
   buildCounterRollingUpdateErrorErrors--;
   return o;
 }
 
 checkRollingUpdateErrorErrors(api.RollingUpdateErrorErrors o) {
   buildCounterRollingUpdateErrorErrors++;
   if (buildCounterRollingUpdateErrorErrors < 3) {
     unittest.expect(o.code, unittest.equals('foo'));
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterRollingUpdateErrorErrors--;
 }
 
-buildUnnamed1617() {
+buildUnnamed1749() {
   var o = new core.List<api.RollingUpdateErrorErrors>();
   o.add(buildRollingUpdateErrorErrors());
   o.add(buildRollingUpdateErrorErrors());
   return o;
 }
 
-checkUnnamed1617(core.List<api.RollingUpdateErrorErrors> o) {
+checkUnnamed1749(core.List<api.RollingUpdateErrorErrors> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkRollingUpdateErrorErrors(o[0]);
   checkRollingUpdateErrorErrors(o[1]);
 }
 
 core.int buildCounterRollingUpdateError = 0;
 buildRollingUpdateError() {
   var o = new api.RollingUpdateError();
   buildCounterRollingUpdateError++;
   if (buildCounterRollingUpdateError < 3) {
-    o.errors = buildUnnamed1617();
+    o.errors = buildUnnamed1749();
   }
   buildCounterRollingUpdateError--;
   return o;
 }
 
 checkRollingUpdateError(api.RollingUpdateError o) {
   buildCounterRollingUpdateError++;
   if (buildCounterRollingUpdateError < 3) {
-    checkUnnamed1617(o.errors);
+    checkUnnamed1749(o.errors);
   }
   buildCounterRollingUpdateError--;
 }
 
-core.int buildCounterRollingUpdatePolicyCanary = 0;
-buildRollingUpdatePolicyCanary() {
-  var o = new api.RollingUpdatePolicyCanary();
-  buildCounterRollingUpdatePolicyCanary++;
-  if (buildCounterRollingUpdatePolicyCanary < 3) {
-    o.numInstances = 42;
-  }
-  buildCounterRollingUpdatePolicyCanary--;
+buildUnnamed1750() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
   return o;
 }
 
-checkRollingUpdatePolicyCanary(api.RollingUpdatePolicyCanary o) {
-  buildCounterRollingUpdatePolicyCanary++;
-  if (buildCounterRollingUpdatePolicyCanary < 3) {
-    unittest.expect(o.numInstances, unittest.equals(42));
-  }
-  buildCounterRollingUpdatePolicyCanary--;
+checkUnnamed1750(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 buildCounterRollingUpdatePolicy = 0;
 buildRollingUpdatePolicy() {
   var o = new api.RollingUpdatePolicy();
   buildCounterRollingUpdatePolicy++;
   if (buildCounterRollingUpdatePolicy < 3) {
     o.autoPauseAfterInstances = 42;
-    o.canary = buildRollingUpdatePolicyCanary();
     o.instanceStartupTimeoutSec = 42;
     o.maxNumConcurrentInstances = 42;
     o.maxNumFailedInstances = 42;
     o.minInstanceUpdateTimeSec = 42;
     o.sleepAfterInstanceRestartSec = 42;
   }
   buildCounterRollingUpdatePolicy--;
   return o;
 }
 
 checkRollingUpdatePolicy(api.RollingUpdatePolicy o) {
   buildCounterRollingUpdatePolicy++;
   if (buildCounterRollingUpdatePolicy < 3) {
     unittest.expect(o.autoPauseAfterInstances, unittest.equals(42));
-    checkRollingUpdatePolicyCanary(o.canary);
     unittest.expect(o.instanceStartupTimeoutSec, unittest.equals(42));
     unittest.expect(o.maxNumConcurrentInstances, unittest.equals(42));
     unittest.expect(o.maxNumFailedInstances, unittest.equals(42));
     unittest.expect(o.minInstanceUpdateTimeSec, unittest.equals(42));
     unittest.expect(o.sleepAfterInstanceRestartSec, unittest.equals(42));
   }
   buildCounterRollingUpdatePolicy--;
 }
 
 core.int buildCounterRollingUpdate = 0;
 buildRollingUpdate() {
   var o = new api.RollingUpdate();
   buildCounterRollingUpdate++;
   if (buildCounterRollingUpdate < 3) {
     o.actionType = "foo";
     o.creationTimestamp = "foo";
     o.description = "foo";
     o.error = buildRollingUpdateError();
     o.id = "foo";
     o.instanceGroup = "foo";
     o.instanceGroupManager = "foo";
     o.instanceTemplate = "foo";
+    o.instances = buildUnnamed1750();
     o.kind = "foo";
     o.policy = buildRollingUpdatePolicy();
     o.progress = 42;
     o.selfLink = "foo";
     o.status = "foo";
     o.statusMessage = "foo";
     o.user = "foo";
   }
   buildCounterRollingUpdate--;
   return o;
 }
 
 checkRollingUpdate(api.RollingUpdate o) {
   buildCounterRollingUpdate++;
   if (buildCounterRollingUpdate < 3) {
     unittest.expect(o.actionType, unittest.equals('foo'));
     unittest.expect(o.creationTimestamp, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkRollingUpdateError(o.error);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.instanceGroup, unittest.equals('foo'));
     unittest.expect(o.instanceGroupManager, unittest.equals('foo'));
     unittest.expect(o.instanceTemplate, unittest.equals('foo'));
+    checkUnnamed1750(o.instances);
     unittest.expect(o.kind, unittest.equals('foo'));
     checkRollingUpdatePolicy(o.policy);
     unittest.expect(o.progress, unittest.equals(42));
     unittest.expect(o.selfLink, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.statusMessage, unittest.equals('foo'));
     unittest.expect(o.user, unittest.equals('foo'));
   }
   buildCounterRollingUpdate--;
 }
 
-buildUnnamed1618() {
+buildUnnamed1751() {
   var o = new core.List<api.RollingUpdate>();
   o.add(buildRollingUpdate());
   o.add(buildRollingUpdate());
   return o;
 }
 
-checkUnnamed1618(core.List<api.RollingUpdate> o) {
+checkUnnamed1751(core.List<api.RollingUpdate> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkRollingUpdate(o[0]);
   checkRollingUpdate(o[1]);
 }
 
 core.int buildCounterRollingUpdateList = 0;
 buildRollingUpdateList() {
   var o = new api.RollingUpdateList();
   buildCounterRollingUpdateList++;
   if (buildCounterRollingUpdateList < 3) {
-    o.items = buildUnnamed1618();
+    o.items = buildUnnamed1751();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.selfLink = "foo";
   }
   buildCounterRollingUpdateList--;
   return o;
 }
 
 checkRollingUpdateList(api.RollingUpdateList o) {
   buildCounterRollingUpdateList++;
   if (buildCounterRollingUpdateList < 3) {
-    checkUnnamed1618(o.items);
+    checkUnnamed1751(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     unittest.expect(o.selfLink, unittest.equals('foo'));
   }
   buildCounterRollingUpdateList--;
 }
 
 
 main() {
   unittest.group("obj-schema-InstanceUpdateErrorErrors", () {
@@ skipping 88 matching lines @@
 
   unittest.group("obj-schema-RollingUpdateError", () {
     unittest.test("to-json--from-json", () {
       var o = buildRollingUpdateError();
       var od = new api.RollingUpdateError.fromJson(o.toJson());
       checkRollingUpdateError(od);
     });
   });
 
 
-  unittest.group("obj-schema-RollingUpdatePolicyCanary", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildRollingUpdatePolicyCanary();
-      var od = new api.RollingUpdatePolicyCanary.fromJson(o.toJson());
-      checkRollingUpdatePolicyCanary(od);
-    });
-  });
-
-
   unittest.group("obj-schema-RollingUpdatePolicy", () {
     unittest.test("to-json--from-json", () {
       var o = buildRollingUpdatePolicy();
       var od = new api.RollingUpdatePolicy.fromJson(o.toJson());
       checkRollingUpdatePolicy(od);
     });
   });
 
 
   unittest.group("obj-schema-RollingUpdate", () {
@@ skipping 10 matching lines @@
       var o = buildRollingUpdateList();
       var od = new api.RollingUpdateList.fromJson(o.toJson());
       checkRollingUpdateList(od);
     });
   });
 
 
   unittest.group("resource-RollingUpdatesResourceApi", () {
     unittest.test("method--cancel", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "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 14 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.cancel(arg_project, arg_zone, arg_rollingUpdate).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "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 14 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(buildRollingUpdate());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_project, arg_zone, arg_rollingUpdate).then(unittest.expectAsync(((api.RollingUpdate response) {
         checkRollingUpdate(response);
       })));
     });
 
     unittest.test("method--insert", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_request = buildRollingUpdate();
       var arg_project = "foo";
       var arg_zone = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.RollingUpdate.fromJson(json);
         checkRollingUpdate(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 17 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.insert(arg_request, arg_project, arg_zone).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_filter = "foo";
       var arg_instanceGroupManager = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 21 matching lines @@
         unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
         unittest.expect(queryMap["instanceGroupManager"].first, unittest.equals(arg_instanceGroupManager));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildRollingUpdateList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_project, arg_zone, filter: arg_filter, instanceGroupManager: arg_instanceGroupManager, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.RollingUpdateList response) {
         checkRollingUpdateList(response);
       })));
     });
 
     unittest.test("method--listInstanceUpdates", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "foo";
       var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 20 matching lines @@
         }
         unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
         unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildInstanceUpdateList());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.listInstanceUpdates(arg_project, arg_zone, arg_rollingUpdate, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.InstanceUpdateList response) {
         checkInstanceUpdateList(response);
       })));
     });
 
     unittest.test("method--pause", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "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 14 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.pause(arg_project, arg_zone, arg_rollingUpdate).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--resume", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "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 14 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.resume(arg_project, arg_zone, arg_rollingUpdate).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--rollback", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RollingUpdatesResourceApi res = new api.ReplicapoolupdaterApi(mock).rollingUpdates;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_rollingUpdate = "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 14 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.rollback(arg_project, arg_zone, arg_rollingUpdate).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-ZoneOperationsResourceApi", () {
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.ZoneOperationsResourceApi res = new api.ReplicapoolupdaterApi(mock).zoneOperations;
       var arg_project = "foo";
       var arg_zone = "foo";
       var arg_operation = "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 14 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(buildOperation());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_project, arg_zone, arg_operation).then(unittest.expectAsync(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
   });
 
 
 }