Generate 0.1.0 version of googleapis/googleapis_beta

generated/googleapis/test/compute/v1.dart

+library googleapis.compute.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/compute/v1.dart' as api;
+
+
+
+core.int buildCounterAccessConfig = 0;
+buildAccessConfig() {
+  var o = new api.AccessConfig();
+  buildCounterAccessConfig++;
+  if (buildCounterAccessConfig < 3) {
+    o.kind = "foo";
+    o.name = "foo";
+    o.natIP = "foo";
+    o.type = "foo";
+  }
+  buildCounterAccessConfig--;
+  return o;
+}
+
+checkAccessConfig(api.AccessConfig o) {
+  buildCounterAccessConfig++;
+  if (buildCounterAccessConfig < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.natIP, unittest.equals('foo'));
+    unittest.expect(o.type, unittest.equals('foo'));
+  }
+  buildCounterAccessConfig--;
+}
+
+buildUnnamed839() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed839(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 buildCounterAddress = 0;
+buildAddress() {
+  var o = new api.Address();
+  buildCounterAddress++;
+  if (buildCounterAddress < 3) {
+    o.address = "foo";
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.region = "foo";
+    o.selfLink = "foo";
+    o.status = "foo";
+    o.users = buildUnnamed839();
+  }
+  buildCounterAddress--;
+  return o;
+}
+
+checkAddress(api.Address o) {
+  buildCounterAddress++;
+  if (buildCounterAddress < 3) {
+    unittest.expect(o.address, unittest.equals('foo'));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.region, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+    checkUnnamed839(o.users);
+  }
+  buildCounterAddress--;
+}
+
+buildUnnamed840() {
+  var o = new core.Map<core.String, api.AddressesScopedList>();
+  o["x"] = buildAddressesScopedList();
+  o["y"] = buildAddressesScopedList();
+  return o;
+}
+
+checkUnnamed840(core.Map<core.String, api.AddressesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAddressesScopedList(o["x"]);
+  checkAddressesScopedList(o["y"]);
+}
+
+core.int buildCounterAddressAggregatedList = 0;
+buildAddressAggregatedList() {
+  var o = new api.AddressAggregatedList();
+  buildCounterAddressAggregatedList++;
+  if (buildCounterAddressAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed840();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterAddressAggregatedList--;
+  return o;
+}
+
+checkAddressAggregatedList(api.AddressAggregatedList o) {
+  buildCounterAddressAggregatedList++;
+  if (buildCounterAddressAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed840(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterAddressAggregatedList--;
+}
+
+buildUnnamed841() {
+  var o = new core.List<api.Address>();
+  o.add(buildAddress());
+  o.add(buildAddress());
+  return o;
+}
+
+checkUnnamed841(core.List<api.Address> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAddress(o[0]);
+  checkAddress(o[1]);
+}
+
+core.int buildCounterAddressList = 0;
+buildAddressList() {
+  var o = new api.AddressList();
+  buildCounterAddressList++;
+  if (buildCounterAddressList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed841();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterAddressList--;
+  return o;
+}
+
+checkAddressList(api.AddressList o) {
+  buildCounterAddressList++;
+  if (buildCounterAddressList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed841(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterAddressList--;
+}
+
+buildUnnamed842() {
+  var o = new core.List<api.Address>();
+  o.add(buildAddress());
+  o.add(buildAddress());
+  return o;
+}
+
+checkUnnamed842(core.List<api.Address> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAddress(o[0]);
+  checkAddress(o[1]);
+}
+
+core.int buildCounterAddressesScopedListWarningData = 0;
+buildAddressesScopedListWarningData() {
+  var o = new api.AddressesScopedListWarningData();
+  buildCounterAddressesScopedListWarningData++;
+  if (buildCounterAddressesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterAddressesScopedListWarningData--;
+  return o;
+}
+
+checkAddressesScopedListWarningData(api.AddressesScopedListWarningData o) {
+  buildCounterAddressesScopedListWarningData++;
+  if (buildCounterAddressesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterAddressesScopedListWarningData--;
+}
+
+buildUnnamed843() {
+  var o = new core.List<api.AddressesScopedListWarningData>();
+  o.add(buildAddressesScopedListWarningData());
+  o.add(buildAddressesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed843(core.List<api.AddressesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAddressesScopedListWarningData(o[0]);
+  checkAddressesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterAddressesScopedListWarning = 0;
+buildAddressesScopedListWarning() {
+  var o = new api.AddressesScopedListWarning();
+  buildCounterAddressesScopedListWarning++;
+  if (buildCounterAddressesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed843();
+    o.message = "foo";
+  }
+  buildCounterAddressesScopedListWarning--;
+  return o;
+}
+
+checkAddressesScopedListWarning(api.AddressesScopedListWarning o) {
+  buildCounterAddressesScopedListWarning++;
+  if (buildCounterAddressesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed843(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterAddressesScopedListWarning--;
+}
+
+core.int buildCounterAddressesScopedList = 0;
+buildAddressesScopedList() {
+  var o = new api.AddressesScopedList();
+  buildCounterAddressesScopedList++;
+  if (buildCounterAddressesScopedList < 3) {
+    o.addresses = buildUnnamed842();
+    o.warning = buildAddressesScopedListWarning();
+  }
+  buildCounterAddressesScopedList--;
+  return o;
+}
+
+checkAddressesScopedList(api.AddressesScopedList o) {
+  buildCounterAddressesScopedList++;
+  if (buildCounterAddressesScopedList < 3) {
+    checkUnnamed842(o.addresses);
+    checkAddressesScopedListWarning(o.warning);
+  }
+  buildCounterAddressesScopedList--;
+}
+
+buildUnnamed844() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed844(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 buildCounterAttachedDisk = 0;
+buildAttachedDisk() {
+  var o = new api.AttachedDisk();
+  buildCounterAttachedDisk++;
+  if (buildCounterAttachedDisk < 3) {
+    o.autoDelete = true;
+    o.boot = true;
+    o.deviceName = "foo";
+    o.index = 42;
+    o.initializeParams = buildAttachedDiskInitializeParams();
+    o.kind = "foo";
+    o.licenses = buildUnnamed844();
+    o.mode = "foo";
+    o.source = "foo";
+    o.type = "foo";
+  }
+  buildCounterAttachedDisk--;
+  return o;
+}
+
+checkAttachedDisk(api.AttachedDisk o) {
+  buildCounterAttachedDisk++;
+  if (buildCounterAttachedDisk < 3) {
+    unittest.expect(o.autoDelete, unittest.isTrue);
+    unittest.expect(o.boot, unittest.isTrue);
+    unittest.expect(o.deviceName, unittest.equals('foo'));
+    unittest.expect(o.index, unittest.equals(42));
+    checkAttachedDiskInitializeParams(o.initializeParams);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed844(o.licenses);
+    unittest.expect(o.mode, unittest.equals('foo'));
+    unittest.expect(o.source, unittest.equals('foo'));
+    unittest.expect(o.type, unittest.equals('foo'));
+  }
+  buildCounterAttachedDisk--;
+}
+
+core.int buildCounterAttachedDiskInitializeParams = 0;
+buildAttachedDiskInitializeParams() {
+  var o = new api.AttachedDiskInitializeParams();
+  buildCounterAttachedDiskInitializeParams++;
+  if (buildCounterAttachedDiskInitializeParams < 3) {
+    o.diskName = "foo";
+    o.diskSizeGb = "foo";
+    o.diskType = "foo";
+    o.sourceImage = "foo";
+  }
+  buildCounterAttachedDiskInitializeParams--;
+  return o;
+}
+
+checkAttachedDiskInitializeParams(api.AttachedDiskInitializeParams o) {
+  buildCounterAttachedDiskInitializeParams++;
+  if (buildCounterAttachedDiskInitializeParams < 3) {
+    unittest.expect(o.diskName, unittest.equals('foo'));
+    unittest.expect(o.diskSizeGb, unittest.equals('foo'));
+    unittest.expect(o.diskType, unittest.equals('foo'));
+    unittest.expect(o.sourceImage, unittest.equals('foo'));
+  }
+  buildCounterAttachedDiskInitializeParams--;
+}
+
+core.int buildCounterBackend = 0;
+buildBackend() {
+  var o = new api.Backend();
+  buildCounterBackend++;
+  if (buildCounterBackend < 3) {
+    o.balancingMode = "foo";
+    o.capacityScaler = 42.0;
+    o.description = "foo";
+    o.group = "foo";
+    o.maxRate = 42;
+    o.maxRatePerInstance = 42.0;
+    o.maxUtilization = 42.0;
+  }
+  buildCounterBackend--;
+  return o;
+}
+
+checkBackend(api.Backend o) {
+  buildCounterBackend++;
+  if (buildCounterBackend < 3) {
+    unittest.expect(o.balancingMode, unittest.equals('foo'));
+    unittest.expect(o.capacityScaler, unittest.equals(42.0));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.group, unittest.equals('foo'));
+    unittest.expect(o.maxRate, unittest.equals(42));
+    unittest.expect(o.maxRatePerInstance, unittest.equals(42.0));
+    unittest.expect(o.maxUtilization, unittest.equals(42.0));
+  }
+  buildCounterBackend--;
+}
+
+buildUnnamed845() {
+  var o = new core.List<api.Backend>();
+  o.add(buildBackend());
+  o.add(buildBackend());
+  return o;
+}
+
+checkUnnamed845(core.List<api.Backend> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBackend(o[0]);
+  checkBackend(o[1]);
+}
+
+buildUnnamed846() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed846(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 buildCounterBackendService = 0;
+buildBackendService() {
+  var o = new api.BackendService();
+  buildCounterBackendService++;
+  if (buildCounterBackendService < 3) {
+    o.backends = buildUnnamed845();
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.fingerprint = "foo";
+    o.healthChecks = buildUnnamed846();
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.port = 42;
+    o.portName = "foo";
+    o.protocol = "foo";
+    o.selfLink = "foo";
+    o.timeoutSec = 42;
+  }
+  buildCounterBackendService--;
+  return o;
+}
+
+checkBackendService(api.BackendService o) {
+  buildCounterBackendService++;
+  if (buildCounterBackendService < 3) {
+    checkUnnamed845(o.backends);
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+    checkUnnamed846(o.healthChecks);
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.port, unittest.equals(42));
+    unittest.expect(o.portName, unittest.equals('foo'));
+    unittest.expect(o.protocol, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.timeoutSec, unittest.equals(42));
+  }
+  buildCounterBackendService--;
+}
+
+buildUnnamed847() {
+  var o = new core.List<api.HealthStatus>();
+  o.add(buildHealthStatus());
+  o.add(buildHealthStatus());
+  return o;
+}
+
+checkUnnamed847(core.List<api.HealthStatus> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHealthStatus(o[0]);
+  checkHealthStatus(o[1]);
+}
+
+core.int buildCounterBackendServiceGroupHealth = 0;
+buildBackendServiceGroupHealth() {
+  var o = new api.BackendServiceGroupHealth();
+  buildCounterBackendServiceGroupHealth++;
+  if (buildCounterBackendServiceGroupHealth < 3) {
+    o.healthStatus = buildUnnamed847();
+    o.kind = "foo";
+  }
+  buildCounterBackendServiceGroupHealth--;
+  return o;
+}
+
+checkBackendServiceGroupHealth(api.BackendServiceGroupHealth o) {
+  buildCounterBackendServiceGroupHealth++;
+  if (buildCounterBackendServiceGroupHealth < 3) {
+    checkUnnamed847(o.healthStatus);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterBackendServiceGroupHealth--;
+}
+
+buildUnnamed848() {
+  var o = new core.List<api.BackendService>();
+  o.add(buildBackendService());
+  o.add(buildBackendService());
+  return o;
+}
+
+checkUnnamed848(core.List<api.BackendService> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBackendService(o[0]);
+  checkBackendService(o[1]);
+}
+
+core.int buildCounterBackendServiceList = 0;
+buildBackendServiceList() {
+  var o = new api.BackendServiceList();
+  buildCounterBackendServiceList++;
+  if (buildCounterBackendServiceList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed848();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterBackendServiceList--;
+  return o;
+}
+
+checkBackendServiceList(api.BackendServiceList o) {
+  buildCounterBackendServiceList++;
+  if (buildCounterBackendServiceList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed848(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterBackendServiceList--;
+}
+
+core.int buildCounterDeprecationStatus = 0;
+buildDeprecationStatus() {
+  var o = new api.DeprecationStatus();
+  buildCounterDeprecationStatus++;
+  if (buildCounterDeprecationStatus < 3) {
+    o.deleted = "foo";
+    o.deprecated = "foo";
+    o.obsolete = "foo";
+    o.replacement = "foo";
+    o.state = "foo";
+  }
+  buildCounterDeprecationStatus--;
+  return o;
+}
+
+checkDeprecationStatus(api.DeprecationStatus o) {
+  buildCounterDeprecationStatus++;
+  if (buildCounterDeprecationStatus < 3) {
+    unittest.expect(o.deleted, unittest.equals('foo'));
+    unittest.expect(o.deprecated, unittest.equals('foo'));
+    unittest.expect(o.obsolete, unittest.equals('foo'));
+    unittest.expect(o.replacement, unittest.equals('foo'));
+    unittest.expect(o.state, unittest.equals('foo'));
+  }
+  buildCounterDeprecationStatus--;
+}
+
+buildUnnamed849() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed849(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 buildCounterDisk = 0;
+buildDisk() {
+  var o = new api.Disk();
+  buildCounterDisk++;
+  if (buildCounterDisk < 3) {
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.licenses = buildUnnamed849();
+    o.name = "foo";
+    o.options = "foo";
+    o.selfLink = "foo";
+    o.sizeGb = "foo";
+    o.sourceImage = "foo";
+    o.sourceImageId = "foo";
+    o.sourceSnapshot = "foo";
+    o.sourceSnapshotId = "foo";
+    o.status = "foo";
+    o.type = "foo";
+    o.zone = "foo";
+  }
+  buildCounterDisk--;
+  return o;
+}
+
+checkDisk(api.Disk o) {
+  buildCounterDisk++;
+  if (buildCounterDisk < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed849(o.licenses);
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.options, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.sizeGb, unittest.equals('foo'));
+    unittest.expect(o.sourceImage, unittest.equals('foo'));
+    unittest.expect(o.sourceImageId, unittest.equals('foo'));
+    unittest.expect(o.sourceSnapshot, unittest.equals('foo'));
+    unittest.expect(o.sourceSnapshotId, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+    unittest.expect(o.type, unittest.equals('foo'));
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterDisk--;
+}
+
+buildUnnamed850() {
+  var o = new core.Map<core.String, api.DisksScopedList>();
+  o["x"] = buildDisksScopedList();
+  o["y"] = buildDisksScopedList();
+  return o;
+}
+
+checkUnnamed850(core.Map<core.String, api.DisksScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDisksScopedList(o["x"]);
+  checkDisksScopedList(o["y"]);
+}
+
+core.int buildCounterDiskAggregatedList = 0;
+buildDiskAggregatedList() {
+  var o = new api.DiskAggregatedList();
+  buildCounterDiskAggregatedList++;
+  if (buildCounterDiskAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed850();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterDiskAggregatedList--;
+  return o;
+}
+
+checkDiskAggregatedList(api.DiskAggregatedList o) {
+  buildCounterDiskAggregatedList++;
+  if (buildCounterDiskAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed850(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterDiskAggregatedList--;
+}
+
+buildUnnamed851() {
+  var o = new core.List<api.Disk>();
+  o.add(buildDisk());
+  o.add(buildDisk());
+  return o;
+}
+
+checkUnnamed851(core.List<api.Disk> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDisk(o[0]);
+  checkDisk(o[1]);
+}
+
+core.int buildCounterDiskList = 0;
+buildDiskList() {
+  var o = new api.DiskList();
+  buildCounterDiskList++;
+  if (buildCounterDiskList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed851();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterDiskList--;
+  return o;
+}
+
+checkDiskList(api.DiskList o) {
+  buildCounterDiskList++;
+  if (buildCounterDiskList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed851(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterDiskList--;
+}
+
+core.int buildCounterDiskType = 0;
+buildDiskType() {
+  var o = new api.DiskType();
+  buildCounterDiskType++;
+  if (buildCounterDiskType < 3) {
+    o.creationTimestamp = "foo";
+    o.defaultDiskSizeGb = "foo";
+    o.deprecated = buildDeprecationStatus();
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.selfLink = "foo";
+    o.validDiskSize = "foo";
+    o.zone = "foo";
+  }
+  buildCounterDiskType--;
+  return o;
+}
+
+checkDiskType(api.DiskType o) {
+  buildCounterDiskType++;
+  if (buildCounterDiskType < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.defaultDiskSizeGb, unittest.equals('foo'));
+    checkDeprecationStatus(o.deprecated);
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.validDiskSize, unittest.equals('foo'));
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterDiskType--;
+}
+
+buildUnnamed852() {
+  var o = new core.Map<core.String, api.DiskTypesScopedList>();
+  o["x"] = buildDiskTypesScopedList();
+  o["y"] = buildDiskTypesScopedList();
+  return o;
+}
+
+checkUnnamed852(core.Map<core.String, api.DiskTypesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDiskTypesScopedList(o["x"]);
+  checkDiskTypesScopedList(o["y"]);
+}
+
+core.int buildCounterDiskTypeAggregatedList = 0;
+buildDiskTypeAggregatedList() {
+  var o = new api.DiskTypeAggregatedList();
+  buildCounterDiskTypeAggregatedList++;
+  if (buildCounterDiskTypeAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed852();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterDiskTypeAggregatedList--;
+  return o;
+}
+
+checkDiskTypeAggregatedList(api.DiskTypeAggregatedList o) {
+  buildCounterDiskTypeAggregatedList++;
+  if (buildCounterDiskTypeAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed852(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterDiskTypeAggregatedList--;
+}
+
+buildUnnamed853() {
+  var o = new core.List<api.DiskType>();
+  o.add(buildDiskType());
+  o.add(buildDiskType());
+  return o;
+}
+
+checkUnnamed853(core.List<api.DiskType> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDiskType(o[0]);
+  checkDiskType(o[1]);
+}
+
+core.int buildCounterDiskTypeList = 0;
+buildDiskTypeList() {
+  var o = new api.DiskTypeList();
+  buildCounterDiskTypeList++;
+  if (buildCounterDiskTypeList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed853();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterDiskTypeList--;
+  return o;
+}
+
+checkDiskTypeList(api.DiskTypeList o) {
+  buildCounterDiskTypeList++;
+  if (buildCounterDiskTypeList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed853(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterDiskTypeList--;
+}
+
+buildUnnamed854() {
+  var o = new core.List<api.DiskType>();
+  o.add(buildDiskType());
+  o.add(buildDiskType());
+  return o;
+}
+
+checkUnnamed854(core.List<api.DiskType> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDiskType(o[0]);
+  checkDiskType(o[1]);
+}
+
+core.int buildCounterDiskTypesScopedListWarningData = 0;
+buildDiskTypesScopedListWarningData() {
+  var o = new api.DiskTypesScopedListWarningData();
+  buildCounterDiskTypesScopedListWarningData++;
+  if (buildCounterDiskTypesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterDiskTypesScopedListWarningData--;
+  return o;
+}
+
+checkDiskTypesScopedListWarningData(api.DiskTypesScopedListWarningData o) {
+  buildCounterDiskTypesScopedListWarningData++;
+  if (buildCounterDiskTypesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterDiskTypesScopedListWarningData--;
+}
+
+buildUnnamed855() {
+  var o = new core.List<api.DiskTypesScopedListWarningData>();
+  o.add(buildDiskTypesScopedListWarningData());
+  o.add(buildDiskTypesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed855(core.List<api.DiskTypesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDiskTypesScopedListWarningData(o[0]);
+  checkDiskTypesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterDiskTypesScopedListWarning = 0;
+buildDiskTypesScopedListWarning() {
+  var o = new api.DiskTypesScopedListWarning();
+  buildCounterDiskTypesScopedListWarning++;
+  if (buildCounterDiskTypesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed855();
+    o.message = "foo";
+  }
+  buildCounterDiskTypesScopedListWarning--;
+  return o;
+}
+
+checkDiskTypesScopedListWarning(api.DiskTypesScopedListWarning o) {
+  buildCounterDiskTypesScopedListWarning++;
+  if (buildCounterDiskTypesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed855(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterDiskTypesScopedListWarning--;
+}
+
+core.int buildCounterDiskTypesScopedList = 0;
+buildDiskTypesScopedList() {
+  var o = new api.DiskTypesScopedList();
+  buildCounterDiskTypesScopedList++;
+  if (buildCounterDiskTypesScopedList < 3) {
+    o.diskTypes = buildUnnamed854();
+    o.warning = buildDiskTypesScopedListWarning();
+  }
+  buildCounterDiskTypesScopedList--;
+  return o;
+}
+
+checkDiskTypesScopedList(api.DiskTypesScopedList o) {
+  buildCounterDiskTypesScopedList++;
+  if (buildCounterDiskTypesScopedList < 3) {
+    checkUnnamed854(o.diskTypes);
+    checkDiskTypesScopedListWarning(o.warning);
+  }
+  buildCounterDiskTypesScopedList--;
+}
+
+buildUnnamed856() {
+  var o = new core.List<api.Disk>();
+  o.add(buildDisk());
+  o.add(buildDisk());
+  return o;
+}
+
+checkUnnamed856(core.List<api.Disk> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDisk(o[0]);
+  checkDisk(o[1]);
+}
+
+core.int buildCounterDisksScopedListWarningData = 0;
+buildDisksScopedListWarningData() {
+  var o = new api.DisksScopedListWarningData();
+  buildCounterDisksScopedListWarningData++;
+  if (buildCounterDisksScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterDisksScopedListWarningData--;
+  return o;
+}
+
+checkDisksScopedListWarningData(api.DisksScopedListWarningData o) {
+  buildCounterDisksScopedListWarningData++;
+  if (buildCounterDisksScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterDisksScopedListWarningData--;
+}
+
+buildUnnamed857() {
+  var o = new core.List<api.DisksScopedListWarningData>();
+  o.add(buildDisksScopedListWarningData());
+  o.add(buildDisksScopedListWarningData());
+  return o;
+}
+
+checkUnnamed857(core.List<api.DisksScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDisksScopedListWarningData(o[0]);
+  checkDisksScopedListWarningData(o[1]);
+}
+
+core.int buildCounterDisksScopedListWarning = 0;
+buildDisksScopedListWarning() {
+  var o = new api.DisksScopedListWarning();
+  buildCounterDisksScopedListWarning++;
+  if (buildCounterDisksScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed857();
+    o.message = "foo";
+  }
+  buildCounterDisksScopedListWarning--;
+  return o;
+}
+
+checkDisksScopedListWarning(api.DisksScopedListWarning o) {
+  buildCounterDisksScopedListWarning++;
+  if (buildCounterDisksScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed857(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterDisksScopedListWarning--;
+}
+
+core.int buildCounterDisksScopedList = 0;
+buildDisksScopedList() {
+  var o = new api.DisksScopedList();
+  buildCounterDisksScopedList++;
+  if (buildCounterDisksScopedList < 3) {
+    o.disks = buildUnnamed856();
+    o.warning = buildDisksScopedListWarning();
+  }
+  buildCounterDisksScopedList--;
+  return o;
+}
+
+checkDisksScopedList(api.DisksScopedList o) {
+  buildCounterDisksScopedList++;
+  if (buildCounterDisksScopedList < 3) {
+    checkUnnamed856(o.disks);
+    checkDisksScopedListWarning(o.warning);
+  }
+  buildCounterDisksScopedList--;
+}
+
+buildUnnamed858() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed858(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 buildCounterFirewallAllowed = 0;
+buildFirewallAllowed() {
+  var o = new api.FirewallAllowed();
+  buildCounterFirewallAllowed++;
+  if (buildCounterFirewallAllowed < 3) {
+    o.IPProtocol = "foo";
+    o.ports = buildUnnamed858();
+  }
+  buildCounterFirewallAllowed--;
+  return o;
+}
+
+checkFirewallAllowed(api.FirewallAllowed o) {
+  buildCounterFirewallAllowed++;
+  if (buildCounterFirewallAllowed < 3) {
+    unittest.expect(o.IPProtocol, unittest.equals('foo'));
+    checkUnnamed858(o.ports);
+  }
+  buildCounterFirewallAllowed--;
+}
+
+buildUnnamed859() {
+  var o = new core.List<api.FirewallAllowed>();
+  o.add(buildFirewallAllowed());
+  o.add(buildFirewallAllowed());
+  return o;
+}
+
+checkUnnamed859(core.List<api.FirewallAllowed> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkFirewallAllowed(o[0]);
+  checkFirewallAllowed(o[1]);
+}
+
+buildUnnamed860() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed860(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'));
+}
+
+buildUnnamed861() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed861(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'));
+}
+
+buildUnnamed862() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed862(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 buildCounterFirewall = 0;
+buildFirewall() {
+  var o = new api.Firewall();
+  buildCounterFirewall++;
+  if (buildCounterFirewall < 3) {
+    o.allowed = buildUnnamed859();
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.network = "foo";
+    o.selfLink = "foo";
+    o.sourceRanges = buildUnnamed860();
+    o.sourceTags = buildUnnamed861();
+    o.targetTags = buildUnnamed862();
+  }
+  buildCounterFirewall--;
+  return o;
+}
+
+checkFirewall(api.Firewall o) {
+  buildCounterFirewall++;
+  if (buildCounterFirewall < 3) {
+    checkUnnamed859(o.allowed);
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.network, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    checkUnnamed860(o.sourceRanges);
+    checkUnnamed861(o.sourceTags);
+    checkUnnamed862(o.targetTags);
+  }
+  buildCounterFirewall--;
+}
+
+buildUnnamed863() {
+  var o = new core.List<api.Firewall>();
+  o.add(buildFirewall());
+  o.add(buildFirewall());
+  return o;
+}
+
+checkUnnamed863(core.List<api.Firewall> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkFirewall(o[0]);
+  checkFirewall(o[1]);
+}
+
+core.int buildCounterFirewallList = 0;
+buildFirewallList() {
+  var o = new api.FirewallList();
+  buildCounterFirewallList++;
+  if (buildCounterFirewallList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed863();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterFirewallList--;
+  return o;
+}
+
+checkFirewallList(api.FirewallList o) {
+  buildCounterFirewallList++;
+  if (buildCounterFirewallList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed863(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterFirewallList--;
+}
+
+core.int buildCounterForwardingRule = 0;
+buildForwardingRule() {
+  var o = new api.ForwardingRule();
+  buildCounterForwardingRule++;
+  if (buildCounterForwardingRule < 3) {
+    o.IPAddress = "foo";
+    o.IPProtocol = "foo";
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.portRange = "foo";
+    o.region = "foo";
+    o.selfLink = "foo";
+    o.target = "foo";
+  }
+  buildCounterForwardingRule--;
+  return o;
+}
+
+checkForwardingRule(api.ForwardingRule o) {
+  buildCounterForwardingRule++;
+  if (buildCounterForwardingRule < 3) {
+    unittest.expect(o.IPAddress, unittest.equals('foo'));
+    unittest.expect(o.IPProtocol, unittest.equals('foo'));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.portRange, unittest.equals('foo'));
+    unittest.expect(o.region, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.target, unittest.equals('foo'));
+  }
+  buildCounterForwardingRule--;
+}
+
+buildUnnamed864() {
+  var o = new core.Map<core.String, api.ForwardingRulesScopedList>();
+  o["x"] = buildForwardingRulesScopedList();
+  o["y"] = buildForwardingRulesScopedList();
+  return o;
+}
+
+checkUnnamed864(core.Map<core.String, api.ForwardingRulesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkForwardingRulesScopedList(o["x"]);
+  checkForwardingRulesScopedList(o["y"]);
+}
+
+core.int buildCounterForwardingRuleAggregatedList = 0;
+buildForwardingRuleAggregatedList() {
+  var o = new api.ForwardingRuleAggregatedList();
+  buildCounterForwardingRuleAggregatedList++;
+  if (buildCounterForwardingRuleAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed864();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterForwardingRuleAggregatedList--;
+  return o;
+}
+
+checkForwardingRuleAggregatedList(api.ForwardingRuleAggregatedList o) {
+  buildCounterForwardingRuleAggregatedList++;
+  if (buildCounterForwardingRuleAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed864(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterForwardingRuleAggregatedList--;
+}
+
+buildUnnamed865() {
+  var o = new core.List<api.ForwardingRule>();
+  o.add(buildForwardingRule());
+  o.add(buildForwardingRule());
+  return o;
+}
+
+checkUnnamed865(core.List<api.ForwardingRule> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkForwardingRule(o[0]);
+  checkForwardingRule(o[1]);
+}
+
+core.int buildCounterForwardingRuleList = 0;
+buildForwardingRuleList() {
+  var o = new api.ForwardingRuleList();
+  buildCounterForwardingRuleList++;
+  if (buildCounterForwardingRuleList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed865();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterForwardingRuleList--;
+  return o;
+}
+
+checkForwardingRuleList(api.ForwardingRuleList o) {
+  buildCounterForwardingRuleList++;
+  if (buildCounterForwardingRuleList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed865(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterForwardingRuleList--;
+}
+
+buildUnnamed866() {
+  var o = new core.List<api.ForwardingRule>();
+  o.add(buildForwardingRule());
+  o.add(buildForwardingRule());
+  return o;
+}
+
+checkUnnamed866(core.List<api.ForwardingRule> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkForwardingRule(o[0]);
+  checkForwardingRule(o[1]);
+}
+
+core.int buildCounterForwardingRulesScopedListWarningData = 0;
+buildForwardingRulesScopedListWarningData() {
+  var o = new api.ForwardingRulesScopedListWarningData();
+  buildCounterForwardingRulesScopedListWarningData++;
+  if (buildCounterForwardingRulesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterForwardingRulesScopedListWarningData--;
+  return o;
+}
+
+checkForwardingRulesScopedListWarningData(api.ForwardingRulesScopedListWarningData o) {
+  buildCounterForwardingRulesScopedListWarningData++;
+  if (buildCounterForwardingRulesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterForwardingRulesScopedListWarningData--;
+}
+
+buildUnnamed867() {
+  var o = new core.List<api.ForwardingRulesScopedListWarningData>();
+  o.add(buildForwardingRulesScopedListWarningData());
+  o.add(buildForwardingRulesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed867(core.List<api.ForwardingRulesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkForwardingRulesScopedListWarningData(o[0]);
+  checkForwardingRulesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterForwardingRulesScopedListWarning = 0;
+buildForwardingRulesScopedListWarning() {
+  var o = new api.ForwardingRulesScopedListWarning();
+  buildCounterForwardingRulesScopedListWarning++;
+  if (buildCounterForwardingRulesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed867();
+    o.message = "foo";
+  }
+  buildCounterForwardingRulesScopedListWarning--;
+  return o;
+}
+
+checkForwardingRulesScopedListWarning(api.ForwardingRulesScopedListWarning o) {
+  buildCounterForwardingRulesScopedListWarning++;
+  if (buildCounterForwardingRulesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed867(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterForwardingRulesScopedListWarning--;
+}
+
+core.int buildCounterForwardingRulesScopedList = 0;
+buildForwardingRulesScopedList() {
+  var o = new api.ForwardingRulesScopedList();
+  buildCounterForwardingRulesScopedList++;
+  if (buildCounterForwardingRulesScopedList < 3) {
+    o.forwardingRules = buildUnnamed866();
+    o.warning = buildForwardingRulesScopedListWarning();
+  }
+  buildCounterForwardingRulesScopedList--;
+  return o;
+}
+
+checkForwardingRulesScopedList(api.ForwardingRulesScopedList o) {
+  buildCounterForwardingRulesScopedList++;
+  if (buildCounterForwardingRulesScopedList < 3) {
+    checkUnnamed866(o.forwardingRules);
+    checkForwardingRulesScopedListWarning(o.warning);
+  }
+  buildCounterForwardingRulesScopedList--;
+}
+
+core.int buildCounterHealthCheckReference = 0;
+buildHealthCheckReference() {
+  var o = new api.HealthCheckReference();
+  buildCounterHealthCheckReference++;
+  if (buildCounterHealthCheckReference < 3) {
+    o.healthCheck = "foo";
+  }
+  buildCounterHealthCheckReference--;
+  return o;
+}
+
+checkHealthCheckReference(api.HealthCheckReference o) {
+  buildCounterHealthCheckReference++;
+  if (buildCounterHealthCheckReference < 3) {
+    unittest.expect(o.healthCheck, unittest.equals('foo'));
+  }
+  buildCounterHealthCheckReference--;
+}
+
+core.int buildCounterHealthStatus = 0;
+buildHealthStatus() {
+  var o = new api.HealthStatus();
+  buildCounterHealthStatus++;
+  if (buildCounterHealthStatus < 3) {
+    o.healthState = "foo";
+    o.instance = "foo";
+    o.ipAddress = "foo";
+    o.port = 42;
+  }
+  buildCounterHealthStatus--;
+  return o;
+}
+
+checkHealthStatus(api.HealthStatus o) {
+  buildCounterHealthStatus++;
+  if (buildCounterHealthStatus < 3) {
+    unittest.expect(o.healthState, unittest.equals('foo'));
+    unittest.expect(o.instance, unittest.equals('foo'));
+    unittest.expect(o.ipAddress, unittest.equals('foo'));
+    unittest.expect(o.port, unittest.equals(42));
+  }
+  buildCounterHealthStatus--;
+}
+
+buildUnnamed868() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed868(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 buildCounterHostRule = 0;
+buildHostRule() {
+  var o = new api.HostRule();
+  buildCounterHostRule++;
+  if (buildCounterHostRule < 3) {
+    o.description = "foo";
+    o.hosts = buildUnnamed868();
+    o.pathMatcher = "foo";
+  }
+  buildCounterHostRule--;
+  return o;
+}
+
+checkHostRule(api.HostRule o) {
+  buildCounterHostRule++;
+  if (buildCounterHostRule < 3) {
+    unittest.expect(o.description, unittest.equals('foo'));
+    checkUnnamed868(o.hosts);
+    unittest.expect(o.pathMatcher, unittest.equals('foo'));
+  }
+  buildCounterHostRule--;
+}
+
+core.int buildCounterHttpHealthCheck = 0;
+buildHttpHealthCheck() {
+  var o = new api.HttpHealthCheck();
+  buildCounterHttpHealthCheck++;
+  if (buildCounterHttpHealthCheck < 3) {
+    o.checkIntervalSec = 42;
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.healthyThreshold = 42;
+    o.host = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.port = 42;
+    o.requestPath = "foo";
+    o.selfLink = "foo";
+    o.timeoutSec = 42;
+    o.unhealthyThreshold = 42;
+  }
+  buildCounterHttpHealthCheck--;
+  return o;
+}
+
+checkHttpHealthCheck(api.HttpHealthCheck o) {
+  buildCounterHttpHealthCheck++;
+  if (buildCounterHttpHealthCheck < 3) {
+    unittest.expect(o.checkIntervalSec, unittest.equals(42));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.healthyThreshold, unittest.equals(42));
+    unittest.expect(o.host, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.port, unittest.equals(42));
+    unittest.expect(o.requestPath, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.timeoutSec, unittest.equals(42));
+    unittest.expect(o.unhealthyThreshold, unittest.equals(42));
+  }
+  buildCounterHttpHealthCheck--;
+}
+
+buildUnnamed869() {
+  var o = new core.List<api.HttpHealthCheck>();
+  o.add(buildHttpHealthCheck());
+  o.add(buildHttpHealthCheck());
+  return o;
+}
+
+checkUnnamed869(core.List<api.HttpHealthCheck> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHttpHealthCheck(o[0]);
+  checkHttpHealthCheck(o[1]);
+}
+
+core.int buildCounterHttpHealthCheckList = 0;
+buildHttpHealthCheckList() {
+  var o = new api.HttpHealthCheckList();
+  buildCounterHttpHealthCheckList++;
+  if (buildCounterHttpHealthCheckList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed869();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterHttpHealthCheckList--;
+  return o;
+}
+
+checkHttpHealthCheckList(api.HttpHealthCheckList o) {
+  buildCounterHttpHealthCheckList++;
+  if (buildCounterHttpHealthCheckList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed869(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterHttpHealthCheckList--;
+}
+
+buildUnnamed870() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed870(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 buildCounterImageRawDisk = 0;
+buildImageRawDisk() {
+  var o = new api.ImageRawDisk();
+  buildCounterImageRawDisk++;
+  if (buildCounterImageRawDisk < 3) {
+    o.containerType = "foo";
+    o.sha1Checksum = "foo";
+    o.source = "foo";
+  }
+  buildCounterImageRawDisk--;
+  return o;
+}
+
+checkImageRawDisk(api.ImageRawDisk o) {
+  buildCounterImageRawDisk++;
+  if (buildCounterImageRawDisk < 3) {
+    unittest.expect(o.containerType, unittest.equals('foo'));
+    unittest.expect(o.sha1Checksum, unittest.equals('foo'));
+    unittest.expect(o.source, unittest.equals('foo'));
+  }
+  buildCounterImageRawDisk--;
+}
+
+core.int buildCounterImage = 0;
+buildImage() {
+  var o = new api.Image();
+  buildCounterImage++;
+  if (buildCounterImage < 3) {
+    o.archiveSizeBytes = "foo";
+    o.creationTimestamp = "foo";
+    o.deprecated = buildDeprecationStatus();
+    o.description = "foo";
+    o.diskSizeGb = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.licenses = buildUnnamed870();
+    o.name = "foo";
+    o.rawDisk = buildImageRawDisk();
+    o.selfLink = "foo";
+    o.sourceDisk = "foo";
+    o.sourceDiskId = "foo";
+    o.sourceType = "foo";
+    o.status = "foo";
+  }
+  buildCounterImage--;
+  return o;
+}
+
+checkImage(api.Image o) {
+  buildCounterImage++;
+  if (buildCounterImage < 3) {
+    unittest.expect(o.archiveSizeBytes, unittest.equals('foo'));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    checkDeprecationStatus(o.deprecated);
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.diskSizeGb, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed870(o.licenses);
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkImageRawDisk(o.rawDisk);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.sourceDisk, unittest.equals('foo'));
+    unittest.expect(o.sourceDiskId, unittest.equals('foo'));
+    unittest.expect(o.sourceType, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+  }
+  buildCounterImage--;
+}
+
+buildUnnamed871() {
+  var o = new core.List<api.Image>();
+  o.add(buildImage());
+  o.add(buildImage());
+  return o;
+}
+
+checkUnnamed871(core.List<api.Image> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkImage(o[0]);
+  checkImage(o[1]);
+}
+
+core.int buildCounterImageList = 0;
+buildImageList() {
+  var o = new api.ImageList();
+  buildCounterImageList++;
+  if (buildCounterImageList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed871();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterImageList--;
+  return o;
+}
+
+checkImageList(api.ImageList o) {
+  buildCounterImageList++;
+  if (buildCounterImageList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed871(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterImageList--;
+}
+
+buildUnnamed872() {
+  var o = new core.List<api.AttachedDisk>();
+  o.add(buildAttachedDisk());
+  o.add(buildAttachedDisk());
+  return o;
+}
+
+checkUnnamed872(core.List<api.AttachedDisk> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAttachedDisk(o[0]);
+  checkAttachedDisk(o[1]);
+}
+
+buildUnnamed873() {
+  var o = new core.List<api.NetworkInterface>();
+  o.add(buildNetworkInterface());
+  o.add(buildNetworkInterface());
+  return o;
+}
+
+checkUnnamed873(core.List<api.NetworkInterface> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkNetworkInterface(o[0]);
+  checkNetworkInterface(o[1]);
+}
+
+buildUnnamed874() {
+  var o = new core.List<api.ServiceAccount>();
+  o.add(buildServiceAccount());
+  o.add(buildServiceAccount());
+  return o;
+}
+
+checkUnnamed874(core.List<api.ServiceAccount> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkServiceAccount(o[0]);
+  checkServiceAccount(o[1]);
+}
+
+core.int buildCounterInstance = 0;
+buildInstance() {
+  var o = new api.Instance();
+  buildCounterInstance++;
+  if (buildCounterInstance < 3) {
+    o.canIpForward = true;
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.disks = buildUnnamed872();
+    o.id = "foo";
+    o.kind = "foo";
+    o.machineType = "foo";
+    o.metadata = buildMetadata();
+    o.name = "foo";
+    o.networkInterfaces = buildUnnamed873();
+    o.scheduling = buildScheduling();
+    o.selfLink = "foo";
+    o.serviceAccounts = buildUnnamed874();
+    o.status = "foo";
+    o.statusMessage = "foo";
+    o.tags = buildTags();
+    o.zone = "foo";
+  }
+  buildCounterInstance--;
+  return o;
+}
+
+checkInstance(api.Instance o) {
+  buildCounterInstance++;
+  if (buildCounterInstance < 3) {
+    unittest.expect(o.canIpForward, unittest.isTrue);
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    checkUnnamed872(o.disks);
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.machineType, unittest.equals('foo'));
+    checkMetadata(o.metadata);
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed873(o.networkInterfaces);
+    checkScheduling(o.scheduling);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    checkUnnamed874(o.serviceAccounts);
+    unittest.expect(o.status, unittest.equals('foo'));
+    unittest.expect(o.statusMessage, unittest.equals('foo'));
+    checkTags(o.tags);
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterInstance--;
+}
+
+buildUnnamed875() {
+  var o = new core.Map<core.String, api.InstancesScopedList>();
+  o["x"] = buildInstancesScopedList();
+  o["y"] = buildInstancesScopedList();
+  return o;
+}
+
+checkUnnamed875(core.Map<core.String, api.InstancesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstancesScopedList(o["x"]);
+  checkInstancesScopedList(o["y"]);
+}
+
+core.int buildCounterInstanceAggregatedList = 0;
+buildInstanceAggregatedList() {
+  var o = new api.InstanceAggregatedList();
+  buildCounterInstanceAggregatedList++;
+  if (buildCounterInstanceAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed875();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterInstanceAggregatedList--;
+  return o;
+}
+
+checkInstanceAggregatedList(api.InstanceAggregatedList o) {
+  buildCounterInstanceAggregatedList++;
+  if (buildCounterInstanceAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed875(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterInstanceAggregatedList--;
+}
+
+buildUnnamed876() {
+  var o = new core.List<api.Instance>();
+  o.add(buildInstance());
+  o.add(buildInstance());
+  return o;
+}
+
+checkUnnamed876(core.List<api.Instance> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstance(o[0]);
+  checkInstance(o[1]);
+}
+
+core.int buildCounterInstanceList = 0;
+buildInstanceList() {
+  var o = new api.InstanceList();
+  buildCounterInstanceList++;
+  if (buildCounterInstanceList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed876();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterInstanceList--;
+  return o;
+}
+
+checkInstanceList(api.InstanceList o) {
+  buildCounterInstanceList++;
+  if (buildCounterInstanceList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed876(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterInstanceList--;
+}
+
+core.int buildCounterInstanceReference = 0;
+buildInstanceReference() {
+  var o = new api.InstanceReference();
+  buildCounterInstanceReference++;
+  if (buildCounterInstanceReference < 3) {
+    o.instance = "foo";
+  }
+  buildCounterInstanceReference--;
+  return o;
+}
+
+checkInstanceReference(api.InstanceReference o) {
+  buildCounterInstanceReference++;
+  if (buildCounterInstanceReference < 3) {
+    unittest.expect(o.instance, unittest.equals('foo'));
+  }
+  buildCounterInstanceReference--;
+}
+
+buildUnnamed877() {
+  var o = new core.List<api.Instance>();
+  o.add(buildInstance());
+  o.add(buildInstance());
+  return o;
+}
+
+checkUnnamed877(core.List<api.Instance> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstance(o[0]);
+  checkInstance(o[1]);
+}
+
+core.int buildCounterInstancesScopedListWarningData = 0;
+buildInstancesScopedListWarningData() {
+  var o = new api.InstancesScopedListWarningData();
+  buildCounterInstancesScopedListWarningData++;
+  if (buildCounterInstancesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterInstancesScopedListWarningData--;
+  return o;
+}
+
+checkInstancesScopedListWarningData(api.InstancesScopedListWarningData o) {
+  buildCounterInstancesScopedListWarningData++;
+  if (buildCounterInstancesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterInstancesScopedListWarningData--;
+}
+
+buildUnnamed878() {
+  var o = new core.List<api.InstancesScopedListWarningData>();
+  o.add(buildInstancesScopedListWarningData());
+  o.add(buildInstancesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed878(core.List<api.InstancesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstancesScopedListWarningData(o[0]);
+  checkInstancesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterInstancesScopedListWarning = 0;
+buildInstancesScopedListWarning() {
+  var o = new api.InstancesScopedListWarning();
+  buildCounterInstancesScopedListWarning++;
+  if (buildCounterInstancesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed878();
+    o.message = "foo";
+  }
+  buildCounterInstancesScopedListWarning--;
+  return o;
+}
+
+checkInstancesScopedListWarning(api.InstancesScopedListWarning o) {
+  buildCounterInstancesScopedListWarning++;
+  if (buildCounterInstancesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed878(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterInstancesScopedListWarning--;
+}
+
+core.int buildCounterInstancesScopedList = 0;
+buildInstancesScopedList() {
+  var o = new api.InstancesScopedList();
+  buildCounterInstancesScopedList++;
+  if (buildCounterInstancesScopedList < 3) {
+    o.instances = buildUnnamed877();
+    o.warning = buildInstancesScopedListWarning();
+  }
+  buildCounterInstancesScopedList--;
+  return o;
+}
+
+checkInstancesScopedList(api.InstancesScopedList o) {
+  buildCounterInstancesScopedList++;
+  if (buildCounterInstancesScopedList < 3) {
+    checkUnnamed877(o.instances);
+    checkInstancesScopedListWarning(o.warning);
+  }
+  buildCounterInstancesScopedList--;
+}
+
+core.int buildCounterLicense = 0;
+buildLicense() {
+  var o = new api.License();
+  buildCounterLicense++;
+  if (buildCounterLicense < 3) {
+    o.chargesUseFee = true;
+    o.kind = "foo";
+    o.name = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterLicense--;
+  return o;
+}
+
+checkLicense(api.License o) {
+  buildCounterLicense++;
+  if (buildCounterLicense < 3) {
+    unittest.expect(o.chargesUseFee, unittest.isTrue);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterLicense--;
+}
+
+core.int buildCounterMachineTypeScratchDisks = 0;
+buildMachineTypeScratchDisks() {
+  var o = new api.MachineTypeScratchDisks();
+  buildCounterMachineTypeScratchDisks++;
+  if (buildCounterMachineTypeScratchDisks < 3) {
+    o.diskGb = 42;
+  }
+  buildCounterMachineTypeScratchDisks--;
+  return o;
+}
+
+checkMachineTypeScratchDisks(api.MachineTypeScratchDisks o) {
+  buildCounterMachineTypeScratchDisks++;
+  if (buildCounterMachineTypeScratchDisks < 3) {
+    unittest.expect(o.diskGb, unittest.equals(42));
+  }
+  buildCounterMachineTypeScratchDisks--;
+}
+
+buildUnnamed879() {
+  var o = new core.List<api.MachineTypeScratchDisks>();
+  o.add(buildMachineTypeScratchDisks());
+  o.add(buildMachineTypeScratchDisks());
+  return o;
+}
+
+checkUnnamed879(core.List<api.MachineTypeScratchDisks> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMachineTypeScratchDisks(o[0]);
+  checkMachineTypeScratchDisks(o[1]);
+}
+
+core.int buildCounterMachineType = 0;
+buildMachineType() {
+  var o = new api.MachineType();
+  buildCounterMachineType++;
+  if (buildCounterMachineType < 3) {
+    o.creationTimestamp = "foo";
+    o.deprecated = buildDeprecationStatus();
+    o.description = "foo";
+    o.guestCpus = 42;
+    o.id = "foo";
+    o.imageSpaceGb = 42;
+    o.kind = "foo";
+    o.maximumPersistentDisks = 42;
+    o.maximumPersistentDisksSizeGb = "foo";
+    o.memoryMb = 42;
+    o.name = "foo";
+    o.scratchDisks = buildUnnamed879();
+    o.selfLink = "foo";
+    o.zone = "foo";
+  }
+  buildCounterMachineType--;
+  return o;
+}
+
+checkMachineType(api.MachineType o) {
+  buildCounterMachineType++;
+  if (buildCounterMachineType < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    checkDeprecationStatus(o.deprecated);
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.guestCpus, unittest.equals(42));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.imageSpaceGb, unittest.equals(42));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.maximumPersistentDisks, unittest.equals(42));
+    unittest.expect(o.maximumPersistentDisksSizeGb, unittest.equals('foo'));
+    unittest.expect(o.memoryMb, unittest.equals(42));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed879(o.scratchDisks);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterMachineType--;
+}
+
+buildUnnamed880() {
+  var o = new core.Map<core.String, api.MachineTypesScopedList>();
+  o["x"] = buildMachineTypesScopedList();
+  o["y"] = buildMachineTypesScopedList();
+  return o;
+}
+
+checkUnnamed880(core.Map<core.String, api.MachineTypesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMachineTypesScopedList(o["x"]);
+  checkMachineTypesScopedList(o["y"]);
+}
+
+core.int buildCounterMachineTypeAggregatedList = 0;
+buildMachineTypeAggregatedList() {
+  var o = new api.MachineTypeAggregatedList();
+  buildCounterMachineTypeAggregatedList++;
+  if (buildCounterMachineTypeAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed880();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterMachineTypeAggregatedList--;
+  return o;
+}
+
+checkMachineTypeAggregatedList(api.MachineTypeAggregatedList o) {
+  buildCounterMachineTypeAggregatedList++;
+  if (buildCounterMachineTypeAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed880(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterMachineTypeAggregatedList--;
+}
+
+buildUnnamed881() {
+  var o = new core.List<api.MachineType>();
+  o.add(buildMachineType());
+  o.add(buildMachineType());
+  return o;
+}
+
+checkUnnamed881(core.List<api.MachineType> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMachineType(o[0]);
+  checkMachineType(o[1]);
+}
+
+core.int buildCounterMachineTypeList = 0;
+buildMachineTypeList() {
+  var o = new api.MachineTypeList();
+  buildCounterMachineTypeList++;
+  if (buildCounterMachineTypeList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed881();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterMachineTypeList--;
+  return o;
+}
+
+checkMachineTypeList(api.MachineTypeList o) {
+  buildCounterMachineTypeList++;
+  if (buildCounterMachineTypeList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed881(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterMachineTypeList--;
+}
+
+buildUnnamed882() {
+  var o = new core.List<api.MachineType>();
+  o.add(buildMachineType());
+  o.add(buildMachineType());
+  return o;
+}
+
+checkUnnamed882(core.List<api.MachineType> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMachineType(o[0]);
+  checkMachineType(o[1]);
+}
+
+core.int buildCounterMachineTypesScopedListWarningData = 0;
+buildMachineTypesScopedListWarningData() {
+  var o = new api.MachineTypesScopedListWarningData();
+  buildCounterMachineTypesScopedListWarningData++;
+  if (buildCounterMachineTypesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterMachineTypesScopedListWarningData--;
+  return o;
+}
+
+checkMachineTypesScopedListWarningData(api.MachineTypesScopedListWarningData o) {
+  buildCounterMachineTypesScopedListWarningData++;
+  if (buildCounterMachineTypesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterMachineTypesScopedListWarningData--;
+}
+
+buildUnnamed883() {
+  var o = new core.List<api.MachineTypesScopedListWarningData>();
+  o.add(buildMachineTypesScopedListWarningData());
+  o.add(buildMachineTypesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed883(core.List<api.MachineTypesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMachineTypesScopedListWarningData(o[0]);
+  checkMachineTypesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterMachineTypesScopedListWarning = 0;
+buildMachineTypesScopedListWarning() {
+  var o = new api.MachineTypesScopedListWarning();
+  buildCounterMachineTypesScopedListWarning++;
+  if (buildCounterMachineTypesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed883();
+    o.message = "foo";
+  }
+  buildCounterMachineTypesScopedListWarning--;
+  return o;
+}
+
+checkMachineTypesScopedListWarning(api.MachineTypesScopedListWarning o) {
+  buildCounterMachineTypesScopedListWarning++;
+  if (buildCounterMachineTypesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed883(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterMachineTypesScopedListWarning--;
+}
+
+core.int buildCounterMachineTypesScopedList = 0;
+buildMachineTypesScopedList() {
+  var o = new api.MachineTypesScopedList();
+  buildCounterMachineTypesScopedList++;
+  if (buildCounterMachineTypesScopedList < 3) {
+    o.machineTypes = buildUnnamed882();
+    o.warning = buildMachineTypesScopedListWarning();
+  }
+  buildCounterMachineTypesScopedList--;
+  return o;
+}
+
+checkMachineTypesScopedList(api.MachineTypesScopedList o) {
+  buildCounterMachineTypesScopedList++;
+  if (buildCounterMachineTypesScopedList < 3) {
+    checkUnnamed882(o.machineTypes);
+    checkMachineTypesScopedListWarning(o.warning);
+  }
+  buildCounterMachineTypesScopedList--;
+}
+
+core.int buildCounterMetadataItems = 0;
+buildMetadataItems() {
+  var o = new api.MetadataItems();
+  buildCounterMetadataItems++;
+  if (buildCounterMetadataItems < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterMetadataItems--;
+  return o;
+}
+
+checkMetadataItems(api.MetadataItems o) {
+  buildCounterMetadataItems++;
+  if (buildCounterMetadataItems < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterMetadataItems--;
+}
+
+buildUnnamed884() {
+  var o = new core.List<api.MetadataItems>();
+  o.add(buildMetadataItems());
+  o.add(buildMetadataItems());
+  return o;
+}
+
+checkUnnamed884(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.fingerprint = "foo";
+    o.items = buildUnnamed884();
+    o.kind = "foo";
+  }
+  buildCounterMetadata--;
+  return o;
+}
+
+checkMetadata(api.Metadata o) {
+  buildCounterMetadata++;
+  if (buildCounterMetadata < 3) {
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+    checkUnnamed884(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterMetadata--;
+}
+
+core.int buildCounterNetwork = 0;
+buildNetwork() {
+  var o = new api.Network();
+  buildCounterNetwork++;
+  if (buildCounterNetwork < 3) {
+    o.IPv4Range = "foo";
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.gatewayIPv4 = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterNetwork--;
+  return o;
+}
+
+checkNetwork(api.Network o) {
+  buildCounterNetwork++;
+  if (buildCounterNetwork < 3) {
+    unittest.expect(o.IPv4Range, unittest.equals('foo'));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.gatewayIPv4, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterNetwork--;
+}
+
+buildUnnamed885() {
+  var o = new core.List<api.AccessConfig>();
+  o.add(buildAccessConfig());
+  o.add(buildAccessConfig());
+  return o;
+}
+
+checkUnnamed885(core.List<api.AccessConfig> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAccessConfig(o[0]);
+  checkAccessConfig(o[1]);
+}
+
+core.int buildCounterNetworkInterface = 0;
+buildNetworkInterface() {
+  var o = new api.NetworkInterface();
+  buildCounterNetworkInterface++;
+  if (buildCounterNetworkInterface < 3) {
+    o.accessConfigs = buildUnnamed885();
+    o.name = "foo";
+    o.network = "foo";
+    o.networkIP = "foo";
+  }
+  buildCounterNetworkInterface--;
+  return o;
+}
+
+checkNetworkInterface(api.NetworkInterface o) {
+  buildCounterNetworkInterface++;
+  if (buildCounterNetworkInterface < 3) {
+    checkUnnamed885(o.accessConfigs);
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.network, unittest.equals('foo'));
+    unittest.expect(o.networkIP, unittest.equals('foo'));
+  }
+  buildCounterNetworkInterface--;
+}
+
+buildUnnamed886() {
+  var o = new core.List<api.Network>();
+  o.add(buildNetwork());
+  o.add(buildNetwork());
+  return o;
+}
+
+checkUnnamed886(core.List<api.Network> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkNetwork(o[0]);
+  checkNetwork(o[1]);
+}
+
+core.int buildCounterNetworkList = 0;
+buildNetworkList() {
+  var o = new api.NetworkList();
+  buildCounterNetworkList++;
+  if (buildCounterNetworkList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed886();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterNetworkList--;
+  return o;
+}
+
+checkNetworkList(api.NetworkList o) {
+  buildCounterNetworkList++;
+  if (buildCounterNetworkList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed886(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterNetworkList--;
+}
+
+core.int buildCounterOperationErrorErrors = 0;
+buildOperationErrorErrors() {
+  var o = new api.OperationErrorErrors();
+  buildCounterOperationErrorErrors++;
+  if (buildCounterOperationErrorErrors < 3) {
+    o.code = "foo";
+    o.location = "foo";
+    o.message = "foo";
+  }
+  buildCounterOperationErrorErrors--;
+  return o;
+}
+
+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--;
+}
+
+buildUnnamed887() {
+  var o = new core.List<api.OperationErrorErrors>();
+  o.add(buildOperationErrorErrors());
+  o.add(buildOperationErrorErrors());
+  return o;
+}
+
+checkUnnamed887(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 = buildUnnamed887();
+  }
+  buildCounterOperationError--;
+  return o;
+}
+
+checkOperationError(api.OperationError o) {
+  buildCounterOperationError++;
+  if (buildCounterOperationError < 3) {
+    checkUnnamed887(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--;
+}
+
+buildUnnamed888() {
+  var o = new core.List<api.OperationWarningsData>();
+  o.add(buildOperationWarningsData());
+  o.add(buildOperationWarningsData());
+  return o;
+}
+
+checkUnnamed888(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 = buildUnnamed888();
+    o.message = "foo";
+  }
+  buildCounterOperationWarnings--;
+  return o;
+}
+
+checkOperationWarnings(api.OperationWarnings o) {
+  buildCounterOperationWarnings++;
+  if (buildCounterOperationWarnings < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed888(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterOperationWarnings--;
+}
+
+buildUnnamed889() {
+  var o = new core.List<api.OperationWarnings>();
+  o.add(buildOperationWarnings());
+  o.add(buildOperationWarnings());
+  return o;
+}
+
+checkUnnamed889(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) {
+    o.clientOperationId = "foo";
+    o.creationTimestamp = "foo";
+    o.endTime = "foo";
+    o.error = buildOperationError();
+    o.httpErrorMessage = "foo";
+    o.httpErrorStatusCode = 42;
+    o.id = "foo";
+    o.insertTime = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    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 = buildUnnamed889();
+    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'));
+    checkUnnamed889(o.warnings);
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterOperation--;
+}
+
+buildUnnamed890() {
+  var o = new core.Map<core.String, api.OperationsScopedList>();
+  o["x"] = buildOperationsScopedList();
+  o["y"] = buildOperationsScopedList();
+  return o;
+}
+
+checkUnnamed890(core.Map<core.String, api.OperationsScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkOperationsScopedList(o["x"]);
+  checkOperationsScopedList(o["y"]);
+}
+
+core.int buildCounterOperationAggregatedList = 0;
+buildOperationAggregatedList() {
+  var o = new api.OperationAggregatedList();
+  buildCounterOperationAggregatedList++;
+  if (buildCounterOperationAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed890();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterOperationAggregatedList--;
+  return o;
+}
+
+checkOperationAggregatedList(api.OperationAggregatedList o) {
+  buildCounterOperationAggregatedList++;
+  if (buildCounterOperationAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed890(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterOperationAggregatedList--;
+}
+
+buildUnnamed891() {
+  var o = new core.List<api.Operation>();
+  o.add(buildOperation());
+  o.add(buildOperation());
+  return o;
+}
+
+checkUnnamed891(core.List<api.Operation> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkOperation(o[0]);
+  checkOperation(o[1]);
+}
+
+core.int buildCounterOperationList = 0;
+buildOperationList() {
+  var o = new api.OperationList();
+  buildCounterOperationList++;
+  if (buildCounterOperationList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed891();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterOperationList--;
+  return o;
+}
+
+checkOperationList(api.OperationList o) {
+  buildCounterOperationList++;
+  if (buildCounterOperationList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed891(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterOperationList--;
+}
+
+buildUnnamed892() {
+  var o = new core.List<api.Operation>();
+  o.add(buildOperation());
+  o.add(buildOperation());
+  return o;
+}
+
+checkUnnamed892(core.List<api.Operation> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkOperation(o[0]);
+  checkOperation(o[1]);
+}
+
+core.int buildCounterOperationsScopedListWarningData = 0;
+buildOperationsScopedListWarningData() {
+  var o = new api.OperationsScopedListWarningData();
+  buildCounterOperationsScopedListWarningData++;
+  if (buildCounterOperationsScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterOperationsScopedListWarningData--;
+  return o;
+}
+
+checkOperationsScopedListWarningData(api.OperationsScopedListWarningData o) {
+  buildCounterOperationsScopedListWarningData++;
+  if (buildCounterOperationsScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterOperationsScopedListWarningData--;
+}
+
+buildUnnamed893() {
+  var o = new core.List<api.OperationsScopedListWarningData>();
+  o.add(buildOperationsScopedListWarningData());
+  o.add(buildOperationsScopedListWarningData());
+  return o;
+}
+
+checkUnnamed893(core.List<api.OperationsScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkOperationsScopedListWarningData(o[0]);
+  checkOperationsScopedListWarningData(o[1]);
+}
+
+core.int buildCounterOperationsScopedListWarning = 0;
+buildOperationsScopedListWarning() {
+  var o = new api.OperationsScopedListWarning();
+  buildCounterOperationsScopedListWarning++;
+  if (buildCounterOperationsScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed893();
+    o.message = "foo";
+  }
+  buildCounterOperationsScopedListWarning--;
+  return o;
+}
+
+checkOperationsScopedListWarning(api.OperationsScopedListWarning o) {
+  buildCounterOperationsScopedListWarning++;
+  if (buildCounterOperationsScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed893(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterOperationsScopedListWarning--;
+}
+
+core.int buildCounterOperationsScopedList = 0;
+buildOperationsScopedList() {
+  var o = new api.OperationsScopedList();
+  buildCounterOperationsScopedList++;
+  if (buildCounterOperationsScopedList < 3) {
+    o.operations = buildUnnamed892();
+    o.warning = buildOperationsScopedListWarning();
+  }
+  buildCounterOperationsScopedList--;
+  return o;
+}
+
+checkOperationsScopedList(api.OperationsScopedList o) {
+  buildCounterOperationsScopedList++;
+  if (buildCounterOperationsScopedList < 3) {
+    checkUnnamed892(o.operations);
+    checkOperationsScopedListWarning(o.warning);
+  }
+  buildCounterOperationsScopedList--;
+}
+
+buildUnnamed894() {
+  var o = new core.List<api.PathRule>();
+  o.add(buildPathRule());
+  o.add(buildPathRule());
+  return o;
+}
+
+checkUnnamed894(core.List<api.PathRule> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkPathRule(o[0]);
+  checkPathRule(o[1]);
+}
+
+core.int buildCounterPathMatcher = 0;
+buildPathMatcher() {
+  var o = new api.PathMatcher();
+  buildCounterPathMatcher++;
+  if (buildCounterPathMatcher < 3) {
+    o.defaultService = "foo";
+    o.description = "foo";
+    o.name = "foo";
+    o.pathRules = buildUnnamed894();
+  }
+  buildCounterPathMatcher--;
+  return o;
+}
+
+checkPathMatcher(api.PathMatcher o) {
+  buildCounterPathMatcher++;
+  if (buildCounterPathMatcher < 3) {
+    unittest.expect(o.defaultService, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed894(o.pathRules);
+  }
+  buildCounterPathMatcher--;
+}
+
+buildUnnamed895() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed895(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 buildCounterPathRule = 0;
+buildPathRule() {
+  var o = new api.PathRule();
+  buildCounterPathRule++;
+  if (buildCounterPathRule < 3) {
+    o.paths = buildUnnamed895();
+    o.service = "foo";
+  }
+  buildCounterPathRule--;
+  return o;
+}
+
+checkPathRule(api.PathRule o) {
+  buildCounterPathRule++;
+  if (buildCounterPathRule < 3) {
+    checkUnnamed895(o.paths);
+    unittest.expect(o.service, unittest.equals('foo'));
+  }
+  buildCounterPathRule--;
+}
+
+buildUnnamed896() {
+  var o = new core.List<api.Quota>();
+  o.add(buildQuota());
+  o.add(buildQuota());
+  return o;
+}
+
+checkUnnamed896(core.List<api.Quota> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkQuota(o[0]);
+  checkQuota(o[1]);
+}
+
+core.int buildCounterProject = 0;
+buildProject() {
+  var o = new api.Project();
+  buildCounterProject++;
+  if (buildCounterProject < 3) {
+    o.commonInstanceMetadata = buildMetadata();
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.quotas = buildUnnamed896();
+    o.selfLink = "foo";
+    o.usageExportLocation = buildUsageExportLocation();
+  }
+  buildCounterProject--;
+  return o;
+}
+
+checkProject(api.Project o) {
+  buildCounterProject++;
+  if (buildCounterProject < 3) {
+    checkMetadata(o.commonInstanceMetadata);
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed896(o.quotas);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    checkUsageExportLocation(o.usageExportLocation);
+  }
+  buildCounterProject--;
+}
+
+core.int buildCounterQuota = 0;
+buildQuota() {
+  var o = new api.Quota();
+  buildCounterQuota++;
+  if (buildCounterQuota < 3) {
+    o.limit = 42.0;
+    o.metric = "foo";
+    o.usage = 42.0;
+  }
+  buildCounterQuota--;
+  return o;
+}
+
+checkQuota(api.Quota o) {
+  buildCounterQuota++;
+  if (buildCounterQuota < 3) {
+    unittest.expect(o.limit, unittest.equals(42.0));
+    unittest.expect(o.metric, unittest.equals('foo'));
+    unittest.expect(o.usage, unittest.equals(42.0));
+  }
+  buildCounterQuota--;
+}
+
+buildUnnamed897() {
+  var o = new core.List<api.Quota>();
+  o.add(buildQuota());
+  o.add(buildQuota());
+  return o;
+}
+
+checkUnnamed897(core.List<api.Quota> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkQuota(o[0]);
+  checkQuota(o[1]);
+}
+
+buildUnnamed898() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed898(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 buildCounterRegion = 0;
+buildRegion() {
+  var o = new api.Region();
+  buildCounterRegion++;
+  if (buildCounterRegion < 3) {
+    o.creationTimestamp = "foo";
+    o.deprecated = buildDeprecationStatus();
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.quotas = buildUnnamed897();
+    o.selfLink = "foo";
+    o.status = "foo";
+    o.zones = buildUnnamed898();
+  }
+  buildCounterRegion--;
+  return o;
+}
+
+checkRegion(api.Region o) {
+  buildCounterRegion++;
+  if (buildCounterRegion < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    checkDeprecationStatus(o.deprecated);
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed897(o.quotas);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+    checkUnnamed898(o.zones);
+  }
+  buildCounterRegion--;
+}
+
+buildUnnamed899() {
+  var o = new core.List<api.Region>();
+  o.add(buildRegion());
+  o.add(buildRegion());
+  return o;
+}
+
+checkUnnamed899(core.List<api.Region> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkRegion(o[0]);
+  checkRegion(o[1]);
+}
+
+core.int buildCounterRegionList = 0;
+buildRegionList() {
+  var o = new api.RegionList();
+  buildCounterRegionList++;
+  if (buildCounterRegionList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed899();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterRegionList--;
+  return o;
+}
+
+checkRegionList(api.RegionList o) {
+  buildCounterRegionList++;
+  if (buildCounterRegionList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed899(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterRegionList--;
+}
+
+core.int buildCounterResourceGroupReference = 0;
+buildResourceGroupReference() {
+  var o = new api.ResourceGroupReference();
+  buildCounterResourceGroupReference++;
+  if (buildCounterResourceGroupReference < 3) {
+    o.group = "foo";
+  }
+  buildCounterResourceGroupReference--;
+  return o;
+}
+
+checkResourceGroupReference(api.ResourceGroupReference o) {
+  buildCounterResourceGroupReference++;
+  if (buildCounterResourceGroupReference < 3) {
+    unittest.expect(o.group, unittest.equals('foo'));
+  }
+  buildCounterResourceGroupReference--;
+}
+
+buildUnnamed900() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed900(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 buildCounterRouteWarningsData = 0;
+buildRouteWarningsData() {
+  var o = new api.RouteWarningsData();
+  buildCounterRouteWarningsData++;
+  if (buildCounterRouteWarningsData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterRouteWarningsData--;
+  return o;
+}
+
+checkRouteWarningsData(api.RouteWarningsData o) {
+  buildCounterRouteWarningsData++;
+  if (buildCounterRouteWarningsData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterRouteWarningsData--;
+}
+
+buildUnnamed901() {
+  var o = new core.List<api.RouteWarningsData>();
+  o.add(buildRouteWarningsData());
+  o.add(buildRouteWarningsData());
+  return o;
+}
+
+checkUnnamed901(core.List<api.RouteWarningsData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkRouteWarningsData(o[0]);
+  checkRouteWarningsData(o[1]);
+}
+
+core.int buildCounterRouteWarnings = 0;
+buildRouteWarnings() {
+  var o = new api.RouteWarnings();
+  buildCounterRouteWarnings++;
+  if (buildCounterRouteWarnings < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed901();
+    o.message = "foo";
+  }
+  buildCounterRouteWarnings--;
+  return o;
+}
+
+checkRouteWarnings(api.RouteWarnings o) {
+  buildCounterRouteWarnings++;
+  if (buildCounterRouteWarnings < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed901(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterRouteWarnings--;
+}
+
+buildUnnamed902() {
+  var o = new core.List<api.RouteWarnings>();
+  o.add(buildRouteWarnings());
+  o.add(buildRouteWarnings());
+  return o;
+}
+
+checkUnnamed902(core.List<api.RouteWarnings> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkRouteWarnings(o[0]);
+  checkRouteWarnings(o[1]);
+}
+
+core.int buildCounterRoute = 0;
+buildRoute() {
+  var o = new api.Route();
+  buildCounterRoute++;
+  if (buildCounterRoute < 3) {
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.destRange = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.network = "foo";
+    o.nextHopGateway = "foo";
+    o.nextHopInstance = "foo";
+    o.nextHopIp = "foo";
+    o.nextHopNetwork = "foo";
+    o.priority = 42;
+    o.selfLink = "foo";
+    o.tags = buildUnnamed900();
+    o.warnings = buildUnnamed902();
+  }
+  buildCounterRoute--;
+  return o;
+}
+
+checkRoute(api.Route o) {
+  buildCounterRoute++;
+  if (buildCounterRoute < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.destRange, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.network, unittest.equals('foo'));
+    unittest.expect(o.nextHopGateway, unittest.equals('foo'));
+    unittest.expect(o.nextHopInstance, unittest.equals('foo'));
+    unittest.expect(o.nextHopIp, unittest.equals('foo'));
+    unittest.expect(o.nextHopNetwork, unittest.equals('foo'));
+    unittest.expect(o.priority, unittest.equals(42));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    checkUnnamed900(o.tags);
+    checkUnnamed902(o.warnings);
+  }
+  buildCounterRoute--;
+}
+
+buildUnnamed903() {
+  var o = new core.List<api.Route>();
+  o.add(buildRoute());
+  o.add(buildRoute());
+  return o;
+}
+
+checkUnnamed903(core.List<api.Route> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkRoute(o[0]);
+  checkRoute(o[1]);
+}
+
+core.int buildCounterRouteList = 0;
+buildRouteList() {
+  var o = new api.RouteList();
+  buildCounterRouteList++;
+  if (buildCounterRouteList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed903();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterRouteList--;
+  return o;
+}
+
+checkRouteList(api.RouteList o) {
+  buildCounterRouteList++;
+  if (buildCounterRouteList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed903(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterRouteList--;
+}
+
+core.int buildCounterScheduling = 0;
+buildScheduling() {
+  var o = new api.Scheduling();
+  buildCounterScheduling++;
+  if (buildCounterScheduling < 3) {
+    o.automaticRestart = true;
+    o.onHostMaintenance = "foo";
+  }
+  buildCounterScheduling--;
+  return o;
+}
+
+checkScheduling(api.Scheduling o) {
+  buildCounterScheduling++;
+  if (buildCounterScheduling < 3) {
+    unittest.expect(o.automaticRestart, unittest.isTrue);
+    unittest.expect(o.onHostMaintenance, unittest.equals('foo'));
+  }
+  buildCounterScheduling--;
+}
+
+core.int buildCounterSerialPortOutput = 0;
+buildSerialPortOutput() {
+  var o = new api.SerialPortOutput();
+  buildCounterSerialPortOutput++;
+  if (buildCounterSerialPortOutput < 3) {
+    o.contents = "foo";
+    o.kind = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterSerialPortOutput--;
+  return o;
+}
+
+checkSerialPortOutput(api.SerialPortOutput o) {
+  buildCounterSerialPortOutput++;
+  if (buildCounterSerialPortOutput < 3) {
+    unittest.expect(o.contents, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterSerialPortOutput--;
+}
+
+buildUnnamed904() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed904(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 buildCounterServiceAccount = 0;
+buildServiceAccount() {
+  var o = new api.ServiceAccount();
+  buildCounterServiceAccount++;
+  if (buildCounterServiceAccount < 3) {
+    o.email = "foo";
+    o.scopes = buildUnnamed904();
+  }
+  buildCounterServiceAccount--;
+  return o;
+}
+
+checkServiceAccount(api.ServiceAccount o) {
+  buildCounterServiceAccount++;
+  if (buildCounterServiceAccount < 3) {
+    unittest.expect(o.email, unittest.equals('foo'));
+    checkUnnamed904(o.scopes);
+  }
+  buildCounterServiceAccount--;
+}
+
+buildUnnamed905() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed905(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 buildCounterSnapshot = 0;
+buildSnapshot() {
+  var o = new api.Snapshot();
+  buildCounterSnapshot++;
+  if (buildCounterSnapshot < 3) {
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.diskSizeGb = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.licenses = buildUnnamed905();
+    o.name = "foo";
+    o.selfLink = "foo";
+    o.sourceDisk = "foo";
+    o.sourceDiskId = "foo";
+    o.status = "foo";
+    o.storageBytes = "foo";
+    o.storageBytesStatus = "foo";
+  }
+  buildCounterSnapshot--;
+  return o;
+}
+
+checkSnapshot(api.Snapshot o) {
+  buildCounterSnapshot++;
+  if (buildCounterSnapshot < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.diskSizeGb, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed905(o.licenses);
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.sourceDisk, unittest.equals('foo'));
+    unittest.expect(o.sourceDiskId, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+    unittest.expect(o.storageBytes, unittest.equals('foo'));
+    unittest.expect(o.storageBytesStatus, unittest.equals('foo'));
+  }
+  buildCounterSnapshot--;
+}
+
+buildUnnamed906() {
+  var o = new core.List<api.Snapshot>();
+  o.add(buildSnapshot());
+  o.add(buildSnapshot());
+  return o;
+}
+
+checkUnnamed906(core.List<api.Snapshot> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkSnapshot(o[0]);
+  checkSnapshot(o[1]);
+}
+
+core.int buildCounterSnapshotList = 0;
+buildSnapshotList() {
+  var o = new api.SnapshotList();
+  buildCounterSnapshotList++;
+  if (buildCounterSnapshotList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed906();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterSnapshotList--;
+  return o;
+}
+
+checkSnapshotList(api.SnapshotList o) {
+  buildCounterSnapshotList++;
+  if (buildCounterSnapshotList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed906(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterSnapshotList--;
+}
+
+buildUnnamed907() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed907(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 buildCounterTags = 0;
+buildTags() {
+  var o = new api.Tags();
+  buildCounterTags++;
+  if (buildCounterTags < 3) {
+    o.fingerprint = "foo";
+    o.items = buildUnnamed907();
+  }
+  buildCounterTags--;
+  return o;
+}
+
+checkTags(api.Tags o) {
+  buildCounterTags++;
+  if (buildCounterTags < 3) {
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+    checkUnnamed907(o.items);
+  }
+  buildCounterTags--;
+}
+
+core.int buildCounterTargetHttpProxy = 0;
+buildTargetHttpProxy() {
+  var o = new api.TargetHttpProxy();
+  buildCounterTargetHttpProxy++;
+  if (buildCounterTargetHttpProxy < 3) {
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.selfLink = "foo";
+    o.urlMap = "foo";
+  }
+  buildCounterTargetHttpProxy--;
+  return o;
+}
+
+checkTargetHttpProxy(api.TargetHttpProxy o) {
+  buildCounterTargetHttpProxy++;
+  if (buildCounterTargetHttpProxy < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.urlMap, unittest.equals('foo'));
+  }
+  buildCounterTargetHttpProxy--;
+}
+
+buildUnnamed908() {
+  var o = new core.List<api.TargetHttpProxy>();
+  o.add(buildTargetHttpProxy());
+  o.add(buildTargetHttpProxy());
+  return o;
+}
+
+checkUnnamed908(core.List<api.TargetHttpProxy> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetHttpProxy(o[0]);
+  checkTargetHttpProxy(o[1]);
+}
+
+core.int buildCounterTargetHttpProxyList = 0;
+buildTargetHttpProxyList() {
+  var o = new api.TargetHttpProxyList();
+  buildCounterTargetHttpProxyList++;
+  if (buildCounterTargetHttpProxyList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed908();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterTargetHttpProxyList--;
+  return o;
+}
+
+checkTargetHttpProxyList(api.TargetHttpProxyList o) {
+  buildCounterTargetHttpProxyList++;
+  if (buildCounterTargetHttpProxyList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed908(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterTargetHttpProxyList--;
+}
+
+core.int buildCounterTargetInstance = 0;
+buildTargetInstance() {
+  var o = new api.TargetInstance();
+  buildCounterTargetInstance++;
+  if (buildCounterTargetInstance < 3) {
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.id = "foo";
+    o.instance = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.natPolicy = "foo";
+    o.selfLink = "foo";
+    o.zone = "foo";
+  }
+  buildCounterTargetInstance--;
+  return o;
+}
+
+checkTargetInstance(api.TargetInstance o) {
+  buildCounterTargetInstance++;
+  if (buildCounterTargetInstance < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.instance, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.natPolicy, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.zone, unittest.equals('foo'));
+  }
+  buildCounterTargetInstance--;
+}
+
+buildUnnamed909() {
+  var o = new core.Map<core.String, api.TargetInstancesScopedList>();
+  o["x"] = buildTargetInstancesScopedList();
+  o["y"] = buildTargetInstancesScopedList();
+  return o;
+}
+
+checkUnnamed909(core.Map<core.String, api.TargetInstancesScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetInstancesScopedList(o["x"]);
+  checkTargetInstancesScopedList(o["y"]);
+}
+
+core.int buildCounterTargetInstanceAggregatedList = 0;
+buildTargetInstanceAggregatedList() {
+  var o = new api.TargetInstanceAggregatedList();
+  buildCounterTargetInstanceAggregatedList++;
+  if (buildCounterTargetInstanceAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed909();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterTargetInstanceAggregatedList--;
+  return o;
+}
+
+checkTargetInstanceAggregatedList(api.TargetInstanceAggregatedList o) {
+  buildCounterTargetInstanceAggregatedList++;
+  if (buildCounterTargetInstanceAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed909(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterTargetInstanceAggregatedList--;
+}
+
+buildUnnamed910() {
+  var o = new core.List<api.TargetInstance>();
+  o.add(buildTargetInstance());
+  o.add(buildTargetInstance());
+  return o;
+}
+
+checkUnnamed910(core.List<api.TargetInstance> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetInstance(o[0]);
+  checkTargetInstance(o[1]);
+}
+
+core.int buildCounterTargetInstanceList = 0;
+buildTargetInstanceList() {
+  var o = new api.TargetInstanceList();
+  buildCounterTargetInstanceList++;
+  if (buildCounterTargetInstanceList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed910();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterTargetInstanceList--;
+  return o;
+}
+
+checkTargetInstanceList(api.TargetInstanceList o) {
+  buildCounterTargetInstanceList++;
+  if (buildCounterTargetInstanceList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed910(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterTargetInstanceList--;
+}
+
+buildUnnamed911() {
+  var o = new core.List<api.TargetInstance>();
+  o.add(buildTargetInstance());
+  o.add(buildTargetInstance());
+  return o;
+}
+
+checkUnnamed911(core.List<api.TargetInstance> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetInstance(o[0]);
+  checkTargetInstance(o[1]);
+}
+
+core.int buildCounterTargetInstancesScopedListWarningData = 0;
+buildTargetInstancesScopedListWarningData() {
+  var o = new api.TargetInstancesScopedListWarningData();
+  buildCounterTargetInstancesScopedListWarningData++;
+  if (buildCounterTargetInstancesScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterTargetInstancesScopedListWarningData--;
+  return o;
+}
+
+checkTargetInstancesScopedListWarningData(api.TargetInstancesScopedListWarningData o) {
+  buildCounterTargetInstancesScopedListWarningData++;
+  if (buildCounterTargetInstancesScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterTargetInstancesScopedListWarningData--;
+}
+
+buildUnnamed912() {
+  var o = new core.List<api.TargetInstancesScopedListWarningData>();
+  o.add(buildTargetInstancesScopedListWarningData());
+  o.add(buildTargetInstancesScopedListWarningData());
+  return o;
+}
+
+checkUnnamed912(core.List<api.TargetInstancesScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetInstancesScopedListWarningData(o[0]);
+  checkTargetInstancesScopedListWarningData(o[1]);
+}
+
+core.int buildCounterTargetInstancesScopedListWarning = 0;
+buildTargetInstancesScopedListWarning() {
+  var o = new api.TargetInstancesScopedListWarning();
+  buildCounterTargetInstancesScopedListWarning++;
+  if (buildCounterTargetInstancesScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed912();
+    o.message = "foo";
+  }
+  buildCounterTargetInstancesScopedListWarning--;
+  return o;
+}
+
+checkTargetInstancesScopedListWarning(api.TargetInstancesScopedListWarning o) {
+  buildCounterTargetInstancesScopedListWarning++;
+  if (buildCounterTargetInstancesScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed912(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterTargetInstancesScopedListWarning--;
+}
+
+core.int buildCounterTargetInstancesScopedList = 0;
+buildTargetInstancesScopedList() {
+  var o = new api.TargetInstancesScopedList();
+  buildCounterTargetInstancesScopedList++;
+  if (buildCounterTargetInstancesScopedList < 3) {
+    o.targetInstances = buildUnnamed911();
+    o.warning = buildTargetInstancesScopedListWarning();
+  }
+  buildCounterTargetInstancesScopedList--;
+  return o;
+}
+
+checkTargetInstancesScopedList(api.TargetInstancesScopedList o) {
+  buildCounterTargetInstancesScopedList++;
+  if (buildCounterTargetInstancesScopedList < 3) {
+    checkUnnamed911(o.targetInstances);
+    checkTargetInstancesScopedListWarning(o.warning);
+  }
+  buildCounterTargetInstancesScopedList--;
+}
+
+buildUnnamed913() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed913(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'));
+}
+
+buildUnnamed914() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed914(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 buildCounterTargetPool = 0;
+buildTargetPool() {
+  var o = new api.TargetPool();
+  buildCounterTargetPool++;
+  if (buildCounterTargetPool < 3) {
+    o.backupPool = "foo";
+    o.creationTimestamp = "foo";
+    o.description = "foo";
+    o.failoverRatio = 42.0;
+    o.healthChecks = buildUnnamed913();
+    o.id = "foo";
+    o.instances = buildUnnamed914();
+    o.kind = "foo";
+    o.name = "foo";
+    o.region = "foo";
+    o.selfLink = "foo";
+    o.sessionAffinity = "foo";
+  }
+  buildCounterTargetPool--;
+  return o;
+}
+
+checkTargetPool(api.TargetPool o) {
+  buildCounterTargetPool++;
+  if (buildCounterTargetPool < 3) {
+    unittest.expect(o.backupPool, unittest.equals('foo'));
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.failoverRatio, unittest.equals(42.0));
+    checkUnnamed913(o.healthChecks);
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed914(o.instances);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.region, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.sessionAffinity, unittest.equals('foo'));
+  }
+  buildCounterTargetPool--;
+}
+
+buildUnnamed915() {
+  var o = new core.Map<core.String, api.TargetPoolsScopedList>();
+  o["x"] = buildTargetPoolsScopedList();
+  o["y"] = buildTargetPoolsScopedList();
+  return o;
+}
+
+checkUnnamed915(core.Map<core.String, api.TargetPoolsScopedList> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetPoolsScopedList(o["x"]);
+  checkTargetPoolsScopedList(o["y"]);
+}
+
+core.int buildCounterTargetPoolAggregatedList = 0;
+buildTargetPoolAggregatedList() {
+  var o = new api.TargetPoolAggregatedList();
+  buildCounterTargetPoolAggregatedList++;
+  if (buildCounterTargetPoolAggregatedList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed915();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterTargetPoolAggregatedList--;
+  return o;
+}
+
+checkTargetPoolAggregatedList(api.TargetPoolAggregatedList o) {
+  buildCounterTargetPoolAggregatedList++;
+  if (buildCounterTargetPoolAggregatedList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed915(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterTargetPoolAggregatedList--;
+}
+
+buildUnnamed916() {
+  var o = new core.List<api.HealthStatus>();
+  o.add(buildHealthStatus());
+  o.add(buildHealthStatus());
+  return o;
+}
+
+checkUnnamed916(core.List<api.HealthStatus> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHealthStatus(o[0]);
+  checkHealthStatus(o[1]);
+}
+
+core.int buildCounterTargetPoolInstanceHealth = 0;
+buildTargetPoolInstanceHealth() {
+  var o = new api.TargetPoolInstanceHealth();
+  buildCounterTargetPoolInstanceHealth++;
+  if (buildCounterTargetPoolInstanceHealth < 3) {
+    o.healthStatus = buildUnnamed916();
+    o.kind = "foo";
+  }
+  buildCounterTargetPoolInstanceHealth--;
+  return o;
+}
+
+checkTargetPoolInstanceHealth(api.TargetPoolInstanceHealth o) {
+  buildCounterTargetPoolInstanceHealth++;
+  if (buildCounterTargetPoolInstanceHealth < 3) {
+    checkUnnamed916(o.healthStatus);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterTargetPoolInstanceHealth--;
+}
+
+buildUnnamed917() {
+  var o = new core.List<api.TargetPool>();
+  o.add(buildTargetPool());
+  o.add(buildTargetPool());
+  return o;
+}
+
+checkUnnamed917(core.List<api.TargetPool> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetPool(o[0]);
+  checkTargetPool(o[1]);
+}
+
+core.int buildCounterTargetPoolList = 0;
+buildTargetPoolList() {
+  var o = new api.TargetPoolList();
+  buildCounterTargetPoolList++;
+  if (buildCounterTargetPoolList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed917();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterTargetPoolList--;
+  return o;
+}
+
+checkTargetPoolList(api.TargetPoolList o) {
+  buildCounterTargetPoolList++;
+  if (buildCounterTargetPoolList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed917(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterTargetPoolList--;
+}
+
+buildUnnamed918() {
+  var o = new core.List<api.HealthCheckReference>();
+  o.add(buildHealthCheckReference());
+  o.add(buildHealthCheckReference());
+  return o;
+}
+
+checkUnnamed918(core.List<api.HealthCheckReference> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHealthCheckReference(o[0]);
+  checkHealthCheckReference(o[1]);
+}
+
+core.int buildCounterTargetPoolsAddHealthCheckRequest = 0;
+buildTargetPoolsAddHealthCheckRequest() {
+  var o = new api.TargetPoolsAddHealthCheckRequest();
+  buildCounterTargetPoolsAddHealthCheckRequest++;
+  if (buildCounterTargetPoolsAddHealthCheckRequest < 3) {
+    o.healthChecks = buildUnnamed918();
+  }
+  buildCounterTargetPoolsAddHealthCheckRequest--;
+  return o;
+}
+
+checkTargetPoolsAddHealthCheckRequest(api.TargetPoolsAddHealthCheckRequest o) {
+  buildCounterTargetPoolsAddHealthCheckRequest++;
+  if (buildCounterTargetPoolsAddHealthCheckRequest < 3) {
+    checkUnnamed918(o.healthChecks);
+  }
+  buildCounterTargetPoolsAddHealthCheckRequest--;
+}
+
+buildUnnamed919() {
+  var o = new core.List<api.InstanceReference>();
+  o.add(buildInstanceReference());
+  o.add(buildInstanceReference());
+  return o;
+}
+
+checkUnnamed919(core.List<api.InstanceReference> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstanceReference(o[0]);
+  checkInstanceReference(o[1]);
+}
+
+core.int buildCounterTargetPoolsAddInstanceRequest = 0;
+buildTargetPoolsAddInstanceRequest() {
+  var o = new api.TargetPoolsAddInstanceRequest();
+  buildCounterTargetPoolsAddInstanceRequest++;
+  if (buildCounterTargetPoolsAddInstanceRequest < 3) {
+    o.instances = buildUnnamed919();
+  }
+  buildCounterTargetPoolsAddInstanceRequest--;
+  return o;
+}
+
+checkTargetPoolsAddInstanceRequest(api.TargetPoolsAddInstanceRequest o) {
+  buildCounterTargetPoolsAddInstanceRequest++;
+  if (buildCounterTargetPoolsAddInstanceRequest < 3) {
+    checkUnnamed919(o.instances);
+  }
+  buildCounterTargetPoolsAddInstanceRequest--;
+}
+
+buildUnnamed920() {
+  var o = new core.List<api.HealthCheckReference>();
+  o.add(buildHealthCheckReference());
+  o.add(buildHealthCheckReference());
+  return o;
+}
+
+checkUnnamed920(core.List<api.HealthCheckReference> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHealthCheckReference(o[0]);
+  checkHealthCheckReference(o[1]);
+}
+
+core.int buildCounterTargetPoolsRemoveHealthCheckRequest = 0;
+buildTargetPoolsRemoveHealthCheckRequest() {
+  var o = new api.TargetPoolsRemoveHealthCheckRequest();
+  buildCounterTargetPoolsRemoveHealthCheckRequest++;
+  if (buildCounterTargetPoolsRemoveHealthCheckRequest < 3) {
+    o.healthChecks = buildUnnamed920();
+  }
+  buildCounterTargetPoolsRemoveHealthCheckRequest--;
+  return o;
+}
+
+checkTargetPoolsRemoveHealthCheckRequest(api.TargetPoolsRemoveHealthCheckRequest o) {
+  buildCounterTargetPoolsRemoveHealthCheckRequest++;
+  if (buildCounterTargetPoolsRemoveHealthCheckRequest < 3) {
+    checkUnnamed920(o.healthChecks);
+  }
+  buildCounterTargetPoolsRemoveHealthCheckRequest--;
+}
+
+buildUnnamed921() {
+  var o = new core.List<api.InstanceReference>();
+  o.add(buildInstanceReference());
+  o.add(buildInstanceReference());
+  return o;
+}
+
+checkUnnamed921(core.List<api.InstanceReference> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstanceReference(o[0]);
+  checkInstanceReference(o[1]);
+}
+
+core.int buildCounterTargetPoolsRemoveInstanceRequest = 0;
+buildTargetPoolsRemoveInstanceRequest() {
+  var o = new api.TargetPoolsRemoveInstanceRequest();
+  buildCounterTargetPoolsRemoveInstanceRequest++;
+  if (buildCounterTargetPoolsRemoveInstanceRequest < 3) {
+    o.instances = buildUnnamed921();
+  }
+  buildCounterTargetPoolsRemoveInstanceRequest--;
+  return o;
+}
+
+checkTargetPoolsRemoveInstanceRequest(api.TargetPoolsRemoveInstanceRequest o) {
+  buildCounterTargetPoolsRemoveInstanceRequest++;
+  if (buildCounterTargetPoolsRemoveInstanceRequest < 3) {
+    checkUnnamed921(o.instances);
+  }
+  buildCounterTargetPoolsRemoveInstanceRequest--;
+}
+
+buildUnnamed922() {
+  var o = new core.List<api.TargetPool>();
+  o.add(buildTargetPool());
+  o.add(buildTargetPool());
+  return o;
+}
+
+checkUnnamed922(core.List<api.TargetPool> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetPool(o[0]);
+  checkTargetPool(o[1]);
+}
+
+core.int buildCounterTargetPoolsScopedListWarningData = 0;
+buildTargetPoolsScopedListWarningData() {
+  var o = new api.TargetPoolsScopedListWarningData();
+  buildCounterTargetPoolsScopedListWarningData++;
+  if (buildCounterTargetPoolsScopedListWarningData < 3) {
+    o.key = "foo";
+    o.value = "foo";
+  }
+  buildCounterTargetPoolsScopedListWarningData--;
+  return o;
+}
+
+checkTargetPoolsScopedListWarningData(api.TargetPoolsScopedListWarningData o) {
+  buildCounterTargetPoolsScopedListWarningData++;
+  if (buildCounterTargetPoolsScopedListWarningData < 3) {
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterTargetPoolsScopedListWarningData--;
+}
+
+buildUnnamed923() {
+  var o = new core.List<api.TargetPoolsScopedListWarningData>();
+  o.add(buildTargetPoolsScopedListWarningData());
+  o.add(buildTargetPoolsScopedListWarningData());
+  return o;
+}
+
+checkUnnamed923(core.List<api.TargetPoolsScopedListWarningData> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTargetPoolsScopedListWarningData(o[0]);
+  checkTargetPoolsScopedListWarningData(o[1]);
+}
+
+core.int buildCounterTargetPoolsScopedListWarning = 0;
+buildTargetPoolsScopedListWarning() {
+  var o = new api.TargetPoolsScopedListWarning();
+  buildCounterTargetPoolsScopedListWarning++;
+  if (buildCounterTargetPoolsScopedListWarning < 3) {
+    o.code = "foo";
+    o.data = buildUnnamed923();
+    o.message = "foo";
+  }
+  buildCounterTargetPoolsScopedListWarning--;
+  return o;
+}
+
+checkTargetPoolsScopedListWarning(api.TargetPoolsScopedListWarning o) {
+  buildCounterTargetPoolsScopedListWarning++;
+  if (buildCounterTargetPoolsScopedListWarning < 3) {
+    unittest.expect(o.code, unittest.equals('foo'));
+    checkUnnamed923(o.data);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterTargetPoolsScopedListWarning--;
+}
+
+core.int buildCounterTargetPoolsScopedList = 0;
+buildTargetPoolsScopedList() {
+  var o = new api.TargetPoolsScopedList();
+  buildCounterTargetPoolsScopedList++;
+  if (buildCounterTargetPoolsScopedList < 3) {
+    o.targetPools = buildUnnamed922();
+    o.warning = buildTargetPoolsScopedListWarning();
+  }
+  buildCounterTargetPoolsScopedList--;
+  return o;
+}
+
+checkTargetPoolsScopedList(api.TargetPoolsScopedList o) {
+  buildCounterTargetPoolsScopedList++;
+  if (buildCounterTargetPoolsScopedList < 3) {
+    checkUnnamed922(o.targetPools);
+    checkTargetPoolsScopedListWarning(o.warning);
+  }
+  buildCounterTargetPoolsScopedList--;
+}
+
+core.int buildCounterTargetReference = 0;
+buildTargetReference() {
+  var o = new api.TargetReference();
+  buildCounterTargetReference++;
+  if (buildCounterTargetReference < 3) {
+    o.target = "foo";
+  }
+  buildCounterTargetReference--;
+  return o;
+}
+
+checkTargetReference(api.TargetReference o) {
+  buildCounterTargetReference++;
+  if (buildCounterTargetReference < 3) {
+    unittest.expect(o.target, unittest.equals('foo'));
+  }
+  buildCounterTargetReference--;
+}
+
+core.int buildCounterTestFailure = 0;
+buildTestFailure() {
+  var o = new api.TestFailure();
+  buildCounterTestFailure++;
+  if (buildCounterTestFailure < 3) {
+    o.actualService = "foo";
+    o.expectedService = "foo";
+    o.host = "foo";
+    o.path = "foo";
+  }
+  buildCounterTestFailure--;
+  return o;
+}
+
+checkTestFailure(api.TestFailure o) {
+  buildCounterTestFailure++;
+  if (buildCounterTestFailure < 3) {
+    unittest.expect(o.actualService, unittest.equals('foo'));
+    unittest.expect(o.expectedService, unittest.equals('foo'));
+    unittest.expect(o.host, unittest.equals('foo'));
+    unittest.expect(o.path, unittest.equals('foo'));
+  }
+  buildCounterTestFailure--;
+}
+
+buildUnnamed924() {
+  var o = new core.List<api.HostRule>();
+  o.add(buildHostRule());
+  o.add(buildHostRule());
+  return o;
+}
+
+checkUnnamed924(core.List<api.HostRule> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHostRule(o[0]);
+  checkHostRule(o[1]);
+}
+
+buildUnnamed925() {
+  var o = new core.List<api.PathMatcher>();
+  o.add(buildPathMatcher());
+  o.add(buildPathMatcher());
+  return o;
+}
+
+checkUnnamed925(core.List<api.PathMatcher> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkPathMatcher(o[0]);
+  checkPathMatcher(o[1]);
+}
+
+buildUnnamed926() {
+  var o = new core.List<api.UrlMapTest>();
+  o.add(buildUrlMapTest());
+  o.add(buildUrlMapTest());
+  return o;
+}
+
+checkUnnamed926(core.List<api.UrlMapTest> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUrlMapTest(o[0]);
+  checkUrlMapTest(o[1]);
+}
+
+core.int buildCounterUrlMap = 0;
+buildUrlMap() {
+  var o = new api.UrlMap();
+  buildCounterUrlMap++;
+  if (buildCounterUrlMap < 3) {
+    o.creationTimestamp = "foo";
+    o.defaultService = "foo";
+    o.description = "foo";
+    o.fingerprint = "foo";
+    o.hostRules = buildUnnamed924();
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.pathMatchers = buildUnnamed925();
+    o.selfLink = "foo";
+    o.tests = buildUnnamed926();
+  }
+  buildCounterUrlMap--;
+  return o;
+}
+
+checkUrlMap(api.UrlMap o) {
+  buildCounterUrlMap++;
+  if (buildCounterUrlMap < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    unittest.expect(o.defaultService, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.fingerprint, unittest.equals('foo'));
+    checkUnnamed924(o.hostRules);
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed925(o.pathMatchers);
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    checkUnnamed926(o.tests);
+  }
+  buildCounterUrlMap--;
+}
+
+buildUnnamed927() {
+  var o = new core.List<api.UrlMap>();
+  o.add(buildUrlMap());
+  o.add(buildUrlMap());
+  return o;
+}
+
+checkUnnamed927(core.List<api.UrlMap> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUrlMap(o[0]);
+  checkUrlMap(o[1]);
+}
+
+core.int buildCounterUrlMapList = 0;
+buildUrlMapList() {
+  var o = new api.UrlMapList();
+  buildCounterUrlMapList++;
+  if (buildCounterUrlMapList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed927();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterUrlMapList--;
+  return o;
+}
+
+checkUrlMapList(api.UrlMapList o) {
+  buildCounterUrlMapList++;
+  if (buildCounterUrlMapList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed927(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterUrlMapList--;
+}
+
+core.int buildCounterUrlMapReference = 0;
+buildUrlMapReference() {
+  var o = new api.UrlMapReference();
+  buildCounterUrlMapReference++;
+  if (buildCounterUrlMapReference < 3) {
+    o.urlMap = "foo";
+  }
+  buildCounterUrlMapReference--;
+  return o;
+}
+
+checkUrlMapReference(api.UrlMapReference o) {
+  buildCounterUrlMapReference++;
+  if (buildCounterUrlMapReference < 3) {
+    unittest.expect(o.urlMap, unittest.equals('foo'));
+  }
+  buildCounterUrlMapReference--;
+}
+
+core.int buildCounterUrlMapTest = 0;
+buildUrlMapTest() {
+  var o = new api.UrlMapTest();
+  buildCounterUrlMapTest++;
+  if (buildCounterUrlMapTest < 3) {
+    o.description = "foo";
+    o.host = "foo";
+    o.path = "foo";
+    o.service = "foo";
+  }
+  buildCounterUrlMapTest--;
+  return o;
+}
+
+checkUrlMapTest(api.UrlMapTest o) {
+  buildCounterUrlMapTest++;
+  if (buildCounterUrlMapTest < 3) {
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.host, unittest.equals('foo'));
+    unittest.expect(o.path, unittest.equals('foo'));
+    unittest.expect(o.service, unittest.equals('foo'));
+  }
+  buildCounterUrlMapTest--;
+}
+
+buildUnnamed928() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed928(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'));
+}
+
+buildUnnamed929() {
+  var o = new core.List<api.TestFailure>();
+  o.add(buildTestFailure());
+  o.add(buildTestFailure());
+  return o;
+}
+
+checkUnnamed929(core.List<api.TestFailure> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkTestFailure(o[0]);
+  checkTestFailure(o[1]);
+}
+
+core.int buildCounterUrlMapValidationResult = 0;
+buildUrlMapValidationResult() {
+  var o = new api.UrlMapValidationResult();
+  buildCounterUrlMapValidationResult++;
+  if (buildCounterUrlMapValidationResult < 3) {
+    o.loadErrors = buildUnnamed928();
+    o.loadSucceeded = true;
+    o.testFailures = buildUnnamed929();
+    o.testPassed = true;
+  }
+  buildCounterUrlMapValidationResult--;
+  return o;
+}
+
+checkUrlMapValidationResult(api.UrlMapValidationResult o) {
+  buildCounterUrlMapValidationResult++;
+  if (buildCounterUrlMapValidationResult < 3) {
+    checkUnnamed928(o.loadErrors);
+    unittest.expect(o.loadSucceeded, unittest.isTrue);
+    checkUnnamed929(o.testFailures);
+    unittest.expect(o.testPassed, unittest.isTrue);
+  }
+  buildCounterUrlMapValidationResult--;
+}
+
+core.int buildCounterUrlMapsValidateRequest = 0;
+buildUrlMapsValidateRequest() {
+  var o = new api.UrlMapsValidateRequest();
+  buildCounterUrlMapsValidateRequest++;
+  if (buildCounterUrlMapsValidateRequest < 3) {
+    o.resource = buildUrlMap();
+  }
+  buildCounterUrlMapsValidateRequest--;
+  return o;
+}
+
+checkUrlMapsValidateRequest(api.UrlMapsValidateRequest o) {
+  buildCounterUrlMapsValidateRequest++;
+  if (buildCounterUrlMapsValidateRequest < 3) {
+    checkUrlMap(o.resource);
+  }
+  buildCounterUrlMapsValidateRequest--;
+}
+
+core.int buildCounterUrlMapsValidateResponse = 0;
+buildUrlMapsValidateResponse() {
+  var o = new api.UrlMapsValidateResponse();
+  buildCounterUrlMapsValidateResponse++;
+  if (buildCounterUrlMapsValidateResponse < 3) {
+    o.result = buildUrlMapValidationResult();
+  }
+  buildCounterUrlMapsValidateResponse--;
+  return o;
+}
+
+checkUrlMapsValidateResponse(api.UrlMapsValidateResponse o) {
+  buildCounterUrlMapsValidateResponse++;
+  if (buildCounterUrlMapsValidateResponse < 3) {
+    checkUrlMapValidationResult(o.result);
+  }
+  buildCounterUrlMapsValidateResponse--;
+}
+
+core.int buildCounterUsageExportLocation = 0;
+buildUsageExportLocation() {
+  var o = new api.UsageExportLocation();
+  buildCounterUsageExportLocation++;
+  if (buildCounterUsageExportLocation < 3) {
+    o.bucketName = "foo";
+    o.reportNamePrefix = "foo";
+  }
+  buildCounterUsageExportLocation--;
+  return o;
+}
+
+checkUsageExportLocation(api.UsageExportLocation o) {
+  buildCounterUsageExportLocation++;
+  if (buildCounterUsageExportLocation < 3) {
+    unittest.expect(o.bucketName, unittest.equals('foo'));
+    unittest.expect(o.reportNamePrefix, unittest.equals('foo'));
+  }
+  buildCounterUsageExportLocation--;
+}
+
+core.int buildCounterZoneMaintenanceWindows = 0;
+buildZoneMaintenanceWindows() {
+  var o = new api.ZoneMaintenanceWindows();
+  buildCounterZoneMaintenanceWindows++;
+  if (buildCounterZoneMaintenanceWindows < 3) {
+    o.beginTime = "foo";
+    o.description = "foo";
+    o.endTime = "foo";
+    o.name = "foo";
+  }
+  buildCounterZoneMaintenanceWindows--;
+  return o;
+}
+
+checkZoneMaintenanceWindows(api.ZoneMaintenanceWindows o) {
+  buildCounterZoneMaintenanceWindows++;
+  if (buildCounterZoneMaintenanceWindows < 3) {
+    unittest.expect(o.beginTime, unittest.equals('foo'));
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.endTime, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+  }
+  buildCounterZoneMaintenanceWindows--;
+}
+
+buildUnnamed930() {
+  var o = new core.List<api.ZoneMaintenanceWindows>();
+  o.add(buildZoneMaintenanceWindows());
+  o.add(buildZoneMaintenanceWindows());
+  return o;
+}
+
+checkUnnamed930(core.List<api.ZoneMaintenanceWindows> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkZoneMaintenanceWindows(o[0]);
+  checkZoneMaintenanceWindows(o[1]);
+}
+
+core.int buildCounterZone = 0;
+buildZone() {
+  var o = new api.Zone();
+  buildCounterZone++;
+  if (buildCounterZone < 3) {
+    o.creationTimestamp = "foo";
+    o.deprecated = buildDeprecationStatus();
+    o.description = "foo";
+    o.id = "foo";
+    o.kind = "foo";
+    o.maintenanceWindows = buildUnnamed930();
+    o.name = "foo";
+    o.region = "foo";
+    o.selfLink = "foo";
+    o.status = "foo";
+  }
+  buildCounterZone--;
+  return o;
+}
+
+checkZone(api.Zone o) {
+  buildCounterZone++;
+  if (buildCounterZone < 3) {
+    unittest.expect(o.creationTimestamp, unittest.equals('foo'));
+    checkDeprecationStatus(o.deprecated);
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed930(o.maintenanceWindows);
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.region, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+  }
+  buildCounterZone--;
+}
+
+buildUnnamed931() {
+  var o = new core.List<api.Zone>();
+  o.add(buildZone());
+  o.add(buildZone());
+  return o;
+}
+
+checkUnnamed931(core.List<api.Zone> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkZone(o[0]);
+  checkZone(o[1]);
+}
+
+core.int buildCounterZoneList = 0;
+buildZoneList() {
+  var o = new api.ZoneList();
+  buildCounterZoneList++;
+  if (buildCounterZoneList < 3) {
+    o.id = "foo";
+    o.items = buildUnnamed931();
+    o.kind = "foo";
+    o.nextPageToken = "foo";
+    o.selfLink = "foo";
+  }
+  buildCounterZoneList--;
+  return o;
+}
+
+checkZoneList(api.ZoneList o) {
+  buildCounterZoneList++;
+  if (buildCounterZoneList < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed931(o.items);
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.selfLink, unittest.equals('foo'));
+  }
+  buildCounterZoneList--;
+}
+
+
+main() {
+  unittest.group("obj-schema-AccessConfig", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAccessConfig();
+      var od = new api.AccessConfig.fromJson(o.toJson());
+      checkAccessConfig(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Address", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddress();
+      var od = new api.Address.fromJson(o.toJson());
+      checkAddress(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AddressAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddressAggregatedList();
+      var od = new api.AddressAggregatedList.fromJson(o.toJson());
+      checkAddressAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AddressList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddressList();
+      var od = new api.AddressList.fromJson(o.toJson());
+      checkAddressList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AddressesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddressesScopedListWarningData();
+      var od = new api.AddressesScopedListWarningData.fromJson(o.toJson());
+      checkAddressesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AddressesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddressesScopedListWarning();
+      var od = new api.AddressesScopedListWarning.fromJson(o.toJson());
+      checkAddressesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AddressesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAddressesScopedList();
+      var od = new api.AddressesScopedList.fromJson(o.toJson());
+      checkAddressesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AttachedDisk", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAttachedDisk();
+      var od = new api.AttachedDisk.fromJson(o.toJson());
+      checkAttachedDisk(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AttachedDiskInitializeParams", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAttachedDiskInitializeParams();
+      var od = new api.AttachedDiskInitializeParams.fromJson(o.toJson());
+      checkAttachedDiskInitializeParams(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Backend", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBackend();
+      var od = new api.Backend.fromJson(o.toJson());
+      checkBackend(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BackendService", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBackendService();
+      var od = new api.BackendService.fromJson(o.toJson());
+      checkBackendService(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BackendServiceGroupHealth", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBackendServiceGroupHealth();
+      var od = new api.BackendServiceGroupHealth.fromJson(o.toJson());
+      checkBackendServiceGroupHealth(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BackendServiceList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBackendServiceList();
+      var od = new api.BackendServiceList.fromJson(o.toJson());
+      checkBackendServiceList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DeprecationStatus", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDeprecationStatus();
+      var od = new api.DeprecationStatus.fromJson(o.toJson());
+      checkDeprecationStatus(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Disk", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDisk();
+      var od = new api.Disk.fromJson(o.toJson());
+      checkDisk(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskAggregatedList();
+      var od = new api.DiskAggregatedList.fromJson(o.toJson());
+      checkDiskAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskList();
+      var od = new api.DiskList.fromJson(o.toJson());
+      checkDiskList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskType", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskType();
+      var od = new api.DiskType.fromJson(o.toJson());
+      checkDiskType(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskTypeAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskTypeAggregatedList();
+      var od = new api.DiskTypeAggregatedList.fromJson(o.toJson());
+      checkDiskTypeAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskTypeList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskTypeList();
+      var od = new api.DiskTypeList.fromJson(o.toJson());
+      checkDiskTypeList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskTypesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskTypesScopedListWarningData();
+      var od = new api.DiskTypesScopedListWarningData.fromJson(o.toJson());
+      checkDiskTypesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskTypesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskTypesScopedListWarning();
+      var od = new api.DiskTypesScopedListWarning.fromJson(o.toJson());
+      checkDiskTypesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DiskTypesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDiskTypesScopedList();
+      var od = new api.DiskTypesScopedList.fromJson(o.toJson());
+      checkDiskTypesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DisksScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDisksScopedListWarningData();
+      var od = new api.DisksScopedListWarningData.fromJson(o.toJson());
+      checkDisksScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DisksScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDisksScopedListWarning();
+      var od = new api.DisksScopedListWarning.fromJson(o.toJson());
+      checkDisksScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DisksScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDisksScopedList();
+      var od = new api.DisksScopedList.fromJson(o.toJson());
+      checkDisksScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-FirewallAllowed", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildFirewallAllowed();
+      var od = new api.FirewallAllowed.fromJson(o.toJson());
+      checkFirewallAllowed(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Firewall", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildFirewall();
+      var od = new api.Firewall.fromJson(o.toJson());
+      checkFirewall(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-FirewallList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildFirewallList();
+      var od = new api.FirewallList.fromJson(o.toJson());
+      checkFirewallList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRule", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRule();
+      var od = new api.ForwardingRule.fromJson(o.toJson());
+      checkForwardingRule(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRuleAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRuleAggregatedList();
+      var od = new api.ForwardingRuleAggregatedList.fromJson(o.toJson());
+      checkForwardingRuleAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRuleList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRuleList();
+      var od = new api.ForwardingRuleList.fromJson(o.toJson());
+      checkForwardingRuleList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRulesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRulesScopedListWarningData();
+      var od = new api.ForwardingRulesScopedListWarningData.fromJson(o.toJson());
+      checkForwardingRulesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRulesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRulesScopedListWarning();
+      var od = new api.ForwardingRulesScopedListWarning.fromJson(o.toJson());
+      checkForwardingRulesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ForwardingRulesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildForwardingRulesScopedList();
+      var od = new api.ForwardingRulesScopedList.fromJson(o.toJson());
+      checkForwardingRulesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-HealthCheckReference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHealthCheckReference();
+      var od = new api.HealthCheckReference.fromJson(o.toJson());
+      checkHealthCheckReference(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-HealthStatus", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHealthStatus();
+      var od = new api.HealthStatus.fromJson(o.toJson());
+      checkHealthStatus(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-HostRule", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHostRule();
+      var od = new api.HostRule.fromJson(o.toJson());
+      checkHostRule(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-HttpHealthCheck", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHttpHealthCheck();
+      var od = new api.HttpHealthCheck.fromJson(o.toJson());
+      checkHttpHealthCheck(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-HttpHealthCheckList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHttpHealthCheckList();
+      var od = new api.HttpHealthCheckList.fromJson(o.toJson());
+      checkHttpHealthCheckList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ImageRawDisk", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildImageRawDisk();
+      var od = new api.ImageRawDisk.fromJson(o.toJson());
+      checkImageRawDisk(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Image", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildImage();
+      var od = new api.Image.fromJson(o.toJson());
+      checkImage(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ImageList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildImageList();
+      var od = new api.ImageList.fromJson(o.toJson());
+      checkImageList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Instance", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstance();
+      var od = new api.Instance.fromJson(o.toJson());
+      checkInstance(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstanceAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstanceAggregatedList();
+      var od = new api.InstanceAggregatedList.fromJson(o.toJson());
+      checkInstanceAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstanceList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstanceList();
+      var od = new api.InstanceList.fromJson(o.toJson());
+      checkInstanceList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstanceReference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstanceReference();
+      var od = new api.InstanceReference.fromJson(o.toJson());
+      checkInstanceReference(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstancesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstancesScopedListWarningData();
+      var od = new api.InstancesScopedListWarningData.fromJson(o.toJson());
+      checkInstancesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstancesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstancesScopedListWarning();
+      var od = new api.InstancesScopedListWarning.fromJson(o.toJson());
+      checkInstancesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstancesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstancesScopedList();
+      var od = new api.InstancesScopedList.fromJson(o.toJson());
+      checkInstancesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-License", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildLicense();
+      var od = new api.License.fromJson(o.toJson());
+      checkLicense(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypeScratchDisks", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypeScratchDisks();
+      var od = new api.MachineTypeScratchDisks.fromJson(o.toJson());
+      checkMachineTypeScratchDisks(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineType", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineType();
+      var od = new api.MachineType.fromJson(o.toJson());
+      checkMachineType(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypeAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypeAggregatedList();
+      var od = new api.MachineTypeAggregatedList.fromJson(o.toJson());
+      checkMachineTypeAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypeList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypeList();
+      var od = new api.MachineTypeList.fromJson(o.toJson());
+      checkMachineTypeList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypesScopedListWarningData();
+      var od = new api.MachineTypesScopedListWarningData.fromJson(o.toJson());
+      checkMachineTypesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypesScopedListWarning();
+      var od = new api.MachineTypesScopedListWarning.fromJson(o.toJson());
+      checkMachineTypesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MachineTypesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMachineTypesScopedList();
+      var od = new api.MachineTypesScopedList.fromJson(o.toJson());
+      checkMachineTypesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MetadataItems", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMetadataItems();
+      var od = new api.MetadataItems.fromJson(o.toJson());
+      checkMetadataItems(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Metadata", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMetadata();
+      var od = new api.Metadata.fromJson(o.toJson());
+      checkMetadata(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Network", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNetwork();
+      var od = new api.Network.fromJson(o.toJson());
+      checkNetwork(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-NetworkInterface", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNetworkInterface();
+      var od = new api.NetworkInterface.fromJson(o.toJson());
+      checkNetworkInterface(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-NetworkList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildNetworkList();
+      var od = new api.NetworkList.fromJson(o.toJson());
+      checkNetworkList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationErrorErrors", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationErrorErrors();
+      var od = new api.OperationErrorErrors.fromJson(o.toJson());
+      checkOperationErrorErrors(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationError", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationError();
+      var od = new api.OperationError.fromJson(o.toJson());
+      checkOperationError(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationWarningsData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationWarningsData();
+      var od = new api.OperationWarningsData.fromJson(o.toJson());
+      checkOperationWarningsData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationWarnings", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationWarnings();
+      var od = new api.OperationWarnings.fromJson(o.toJson());
+      checkOperationWarnings(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Operation", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperation();
+      var od = new api.Operation.fromJson(o.toJson());
+      checkOperation(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationAggregatedList();
+      var od = new api.OperationAggregatedList.fromJson(o.toJson());
+      checkOperationAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationList();
+      var od = new api.OperationList.fromJson(o.toJson());
+      checkOperationList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationsScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationsScopedListWarningData();
+      var od = new api.OperationsScopedListWarningData.fromJson(o.toJson());
+      checkOperationsScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationsScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationsScopedListWarning();
+      var od = new api.OperationsScopedListWarning.fromJson(o.toJson());
+      checkOperationsScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-OperationsScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildOperationsScopedList();
+      var od = new api.OperationsScopedList.fromJson(o.toJson());
+      checkOperationsScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-PathMatcher", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildPathMatcher();
+      var od = new api.PathMatcher.fromJson(o.toJson());
+      checkPathMatcher(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-PathRule", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildPathRule();
+      var od = new api.PathRule.fromJson(o.toJson());
+      checkPathRule(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Project", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProject();
+      var od = new api.Project.fromJson(o.toJson());
+      checkProject(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Quota", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildQuota();
+      var od = new api.Quota.fromJson(o.toJson());
+      checkQuota(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Region", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRegion();
+      var od = new api.Region.fromJson(o.toJson());
+      checkRegion(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-RegionList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRegionList();
+      var od = new api.RegionList.fromJson(o.toJson());
+      checkRegionList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ResourceGroupReference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResourceGroupReference();
+      var od = new api.ResourceGroupReference.fromJson(o.toJson());
+      checkResourceGroupReference(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-RouteWarningsData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRouteWarningsData();
+      var od = new api.RouteWarningsData.fromJson(o.toJson());
+      checkRouteWarningsData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-RouteWarnings", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRouteWarnings();
+      var od = new api.RouteWarnings.fromJson(o.toJson());
+      checkRouteWarnings(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Route", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRoute();
+      var od = new api.Route.fromJson(o.toJson());
+      checkRoute(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-RouteList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildRouteList();
+      var od = new api.RouteList.fromJson(o.toJson());
+      checkRouteList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Scheduling", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildScheduling();
+      var od = new api.Scheduling.fromJson(o.toJson());
+      checkScheduling(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SerialPortOutput", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSerialPortOutput();
+      var od = new api.SerialPortOutput.fromJson(o.toJson());
+      checkSerialPortOutput(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ServiceAccount", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildServiceAccount();
+      var od = new api.ServiceAccount.fromJson(o.toJson());
+      checkServiceAccount(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Snapshot", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSnapshot();
+      var od = new api.Snapshot.fromJson(o.toJson());
+      checkSnapshot(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SnapshotList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSnapshotList();
+      var od = new api.SnapshotList.fromJson(o.toJson());
+      checkSnapshotList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Tags", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTags();
+      var od = new api.Tags.fromJson(o.toJson());
+      checkTags(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetHttpProxy", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetHttpProxy();
+      var od = new api.TargetHttpProxy.fromJson(o.toJson());
+      checkTargetHttpProxy(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetHttpProxyList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetHttpProxyList();
+      var od = new api.TargetHttpProxyList.fromJson(o.toJson());
+      checkTargetHttpProxyList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstance", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstance();
+      var od = new api.TargetInstance.fromJson(o.toJson());
+      checkTargetInstance(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstanceAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstanceAggregatedList();
+      var od = new api.TargetInstanceAggregatedList.fromJson(o.toJson());
+      checkTargetInstanceAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstanceList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstanceList();
+      var od = new api.TargetInstanceList.fromJson(o.toJson());
+      checkTargetInstanceList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstancesScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstancesScopedListWarningData();
+      var od = new api.TargetInstancesScopedListWarningData.fromJson(o.toJson());
+      checkTargetInstancesScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstancesScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstancesScopedListWarning();
+      var od = new api.TargetInstancesScopedListWarning.fromJson(o.toJson());
+      checkTargetInstancesScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetInstancesScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetInstancesScopedList();
+      var od = new api.TargetInstancesScopedList.fromJson(o.toJson());
+      checkTargetInstancesScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPool", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPool();
+      var od = new api.TargetPool.fromJson(o.toJson());
+      checkTargetPool(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolAggregatedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolAggregatedList();
+      var od = new api.TargetPoolAggregatedList.fromJson(o.toJson());
+      checkTargetPoolAggregatedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolInstanceHealth", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolInstanceHealth();
+      var od = new api.TargetPoolInstanceHealth.fromJson(o.toJson());
+      checkTargetPoolInstanceHealth(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolList();
+      var od = new api.TargetPoolList.fromJson(o.toJson());
+      checkTargetPoolList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsAddHealthCheckRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsAddHealthCheckRequest();
+      var od = new api.TargetPoolsAddHealthCheckRequest.fromJson(o.toJson());
+      checkTargetPoolsAddHealthCheckRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsAddInstanceRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsAddInstanceRequest();
+      var od = new api.TargetPoolsAddInstanceRequest.fromJson(o.toJson());
+      checkTargetPoolsAddInstanceRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsRemoveHealthCheckRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsRemoveHealthCheckRequest();
+      var od = new api.TargetPoolsRemoveHealthCheckRequest.fromJson(o.toJson());
+      checkTargetPoolsRemoveHealthCheckRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsRemoveInstanceRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsRemoveInstanceRequest();
+      var od = new api.TargetPoolsRemoveInstanceRequest.fromJson(o.toJson());
+      checkTargetPoolsRemoveInstanceRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsScopedListWarningData", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsScopedListWarningData();
+      var od = new api.TargetPoolsScopedListWarningData.fromJson(o.toJson());
+      checkTargetPoolsScopedListWarningData(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsScopedListWarning", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsScopedListWarning();
+      var od = new api.TargetPoolsScopedListWarning.fromJson(o.toJson());
+      checkTargetPoolsScopedListWarning(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetPoolsScopedList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetPoolsScopedList();
+      var od = new api.TargetPoolsScopedList.fromJson(o.toJson());
+      checkTargetPoolsScopedList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TargetReference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTargetReference();
+      var od = new api.TargetReference.fromJson(o.toJson());
+      checkTargetReference(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-TestFailure", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildTestFailure();
+      var od = new api.TestFailure.fromJson(o.toJson());
+      checkTestFailure(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMap", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMap();
+      var od = new api.UrlMap.fromJson(o.toJson());
+      checkUrlMap(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapList();
+      var od = new api.UrlMapList.fromJson(o.toJson());
+      checkUrlMapList(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapReference", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapReference();
+      var od = new api.UrlMapReference.fromJson(o.toJson());
+      checkUrlMapReference(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapTest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapTest();
+      var od = new api.UrlMapTest.fromJson(o.toJson());
+      checkUrlMapTest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapValidationResult", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapValidationResult();
+      var od = new api.UrlMapValidationResult.fromJson(o.toJson());
+      checkUrlMapValidationResult(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapsValidateRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapsValidateRequest();
+      var od = new api.UrlMapsValidateRequest.fromJson(o.toJson());
+      checkUrlMapsValidateRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UrlMapsValidateResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUrlMapsValidateResponse();
+      var od = new api.UrlMapsValidateResponse.fromJson(o.toJson());
+      checkUrlMapsValidateResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UsageExportLocation", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUsageExportLocation();
+      var od = new api.UsageExportLocation.fromJson(o.toJson());
+      checkUsageExportLocation(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ZoneMaintenanceWindows", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildZoneMaintenanceWindows();
+      var od = new api.ZoneMaintenanceWindows.fromJson(o.toJson());
+      checkZoneMaintenanceWindows(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Zone", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildZone();
+      var od = new api.Zone.fromJson(o.toJson());
+      checkZone(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ZoneList", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildZoneList();
+      var od = new api.ZoneList.fromJson(o.toJson());
+      checkZoneList(od);
+    });
+  });
+
+
+  unittest.group("resource-AddressesResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/addresses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/aggregated/addresses"));
+        pathOffset += 21;
+
+        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["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(buildAddressAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AddressAggregatedList response) {
+        checkAddressAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_address = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/addresses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/addresses/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_address"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_region, arg_address).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_address = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/addresses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/addresses/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_address"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildAddress());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_region, arg_address).then(unittest.expectAsync(((api.Address response) {
+        checkAddress(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;
+      var arg_request = buildAddress();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Address.fromJson(json);
+        checkAddress(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/addresses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/addresses"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;
+      var arg_project = "foo";
+      var arg_region = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/addresses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/addresses"));
+        pathOffset += 10;
+
+        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["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(buildAddressList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AddressList response) {
+        checkAddressList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-BackendServicesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_project = "foo";
+      var arg_backendService = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/backendServices/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_backendService"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_backendService).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_project = "foo";
+      var arg_backendService = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/backendServices/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_backendService"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildBackendService());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_backendService).then(unittest.expectAsync(((api.BackendService response) {
+        checkBackendService(response);
+      })));
+    });
+
+    unittest.test("method--getHealth", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_request = buildResourceGroupReference();
+      var arg_project = "foo";
+      var arg_backendService = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ResourceGroupReference.fromJson(json);
+        checkResourceGroupReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/backendServices/"));
+        pathOffset += 24;
+        index = path.indexOf("/getHealth", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_backendService"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/getHealth"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildBackendServiceGroupHealth());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.getHealth(arg_request, arg_project, arg_backendService).then(unittest.expectAsync(((api.BackendServiceGroupHealth response) {
+        checkBackendServiceGroupHealth(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_request = buildBackendService();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.BackendService.fromJson(json);
+        checkBackendService(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("/global/backendServices"));
+        pathOffset += 23;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("/global/backendServices"));
+        pathOffset += 23;
+
+        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["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(buildBackendServiceList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.BackendServiceList response) {
+        checkBackendServiceList(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_request = buildBackendService();
+      var arg_project = "foo";
+      var arg_backendService = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.BackendService.fromJson(json);
+        checkBackendService(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/backendServices/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_backendService"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.patch(arg_request, arg_project, arg_backendService).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServices;
+      var arg_request = buildBackendService();
+      var arg_project = "foo";
+      var arg_backendService = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.BackendService.fromJson(json);
+        checkBackendService(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/backendServices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/backendServices/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_backendService"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.update(arg_request, arg_project, arg_backendService).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-DiskTypesResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/diskTypes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/aggregated/diskTypes"));
+        pathOffset += 21;
+
+        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["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(buildDiskTypeAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskTypeAggregatedList response) {
+        checkDiskTypeAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_diskType = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/diskTypes/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/diskTypes/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_diskType"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDiskType());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone, arg_diskType).then(unittest.expectAsync(((api.DiskType response) {
+        checkDiskType(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/diskTypes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/diskTypes"));
+        pathOffset += 10;
+
+        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["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(buildDiskTypeList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskTypeList response) {
+        checkDiskTypeList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-DisksResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/disks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/aggregated/disks"));
+        pathOffset += 17;
+
+        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["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(buildDiskAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskAggregatedList response) {
+        checkDiskAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--createSnapshot", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_request = buildSnapshot();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_disk = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Snapshot.fromJson(json);
+        checkSnapshot(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/disks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/disks/"));
+        pathOffset += 7;
+        index = path.indexOf("/createSnapshot", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_disk"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/createSnapshot"));
+        pathOffset += 15;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.createSnapshot(arg_request, arg_project, arg_zone, arg_disk).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_disk = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/disks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/disks/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_disk"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_zone, arg_disk).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_disk = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/disks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/disks/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_disk"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDisk());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone, arg_disk).then(unittest.expectAsync(((api.Disk response) {
+        checkDisk(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_request = buildDisk();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_sourceImage = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Disk.fromJson(json);
+        checkDisk(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/disks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/disks"));
+        pathOffset += 6;
+
+        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["sourceImage"].first, unittest.equals(arg_sourceImage));
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project, arg_zone, sourceImage: arg_sourceImage).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.DisksResourceApi res = new api.ComputeApi(mock).disks;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/disks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/disks"));
+        pathOffset += 6;
+
+        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["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(buildDiskList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskList response) {
+        checkDiskList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-FirewallsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_project = "foo";
+      var arg_firewall = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/firewalls/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_firewall"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_firewall).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_project = "foo";
+      var arg_firewall = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/firewalls/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_firewall"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildFirewall());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_firewall).then(unittest.expectAsync(((api.Firewall response) {
+        checkFirewall(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_request = buildFirewall();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Firewall.fromJson(json);
+        checkFirewall(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/firewalls"));
+        pathOffset += 17;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/firewalls"));
+        pathOffset += 17;
+
+        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["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(buildFirewallList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.FirewallList response) {
+        checkFirewallList(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_request = buildFirewall();
+      var arg_project = "foo";
+      var arg_firewall = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Firewall.fromJson(json);
+        checkFirewall(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/firewalls/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_firewall"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.patch(arg_request, arg_project, arg_firewall).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;
+      var arg_request = buildFirewall();
+      var arg_project = "foo";
+      var arg_firewall = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Firewall.fromJson(json);
+        checkFirewall(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/firewalls/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/firewalls/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_firewall"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.update(arg_request, arg_project, arg_firewall).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ForwardingRulesResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/forwardingRules", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.equals("/aggregated/forwardingRules"));
+        pathOffset += 27;
+
+        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["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(buildForwardingRuleAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRuleAggregatedList response) {
+        checkForwardingRuleAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_forwardingRule = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/forwardingRules/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_region, arg_forwardingRule).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_forwardingRule = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/forwardingRules/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildForwardingRule());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_region, arg_forwardingRule).then(unittest.expectAsync(((api.ForwardingRule response) {
+        checkForwardingRule(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_request = buildForwardingRule();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ForwardingRule.fromJson(json);
+        checkForwardingRule(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/forwardingRules", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/forwardingRules"));
+        pathOffset += 16;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_project = "foo";
+      var arg_region = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/forwardingRules", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/forwardingRules"));
+        pathOffset += 16;
+
+        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["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(buildForwardingRuleList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRuleList response) {
+        checkForwardingRuleList(response);
+      })));
+    });
+
+    unittest.test("method--setTarget", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRules;
+      var arg_request = buildTargetReference();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_forwardingRule = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetReference.fromJson(json);
+        checkTargetReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/forwardingRules/"));
+        pathOffset += 17;
+        index = path.indexOf("/setTarget", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/setTarget"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setTarget(arg_request, arg_project, arg_region, arg_forwardingRule).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-GlobalAddressesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddresses;
+      var arg_project = "foo";
+      var arg_address = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/addresses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/addresses/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_address"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_address).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddresses;
+      var arg_project = "foo";
+      var arg_address = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/addresses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/addresses/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_address"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildAddress());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_address).then(unittest.expectAsync(((api.Address response) {
+        checkAddress(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddresses;
+      var arg_request = buildAddress();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Address.fromJson(json);
+        checkAddress(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/addresses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/addresses"));
+        pathOffset += 17;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddresses;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/addresses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/addresses"));
+        pathOffset += 17;
+
+        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["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(buildAddressList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AddressList response) {
+        checkAddressList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-GlobalForwardingRulesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).globalForwardingRules;
+      var arg_project = "foo";
+      var arg_forwardingRule = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/forwardingRules/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_forwardingRule).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).globalForwardingRules;
+      var arg_project = "foo";
+      var arg_forwardingRule = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/forwardingRules/"));
+        pathOffset += 24;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildForwardingRule());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_forwardingRule).then(unittest.expectAsync(((api.ForwardingRule response) {
+        checkForwardingRule(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).globalForwardingRules;
+      var arg_request = buildForwardingRule();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ForwardingRule.fromJson(json);
+        checkForwardingRule(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/forwardingRules", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("/global/forwardingRules"));
+        pathOffset += 23;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).globalForwardingRules;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/forwardingRules", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("/global/forwardingRules"));
+        pathOffset += 23;
+
+        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["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(buildForwardingRuleList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRuleList response) {
+        checkForwardingRuleList(response);
+      })));
+    });
+
+    unittest.test("method--setTarget", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).globalForwardingRules;
+      var arg_request = buildTargetReference();
+      var arg_project = "foo";
+      var arg_forwardingRule = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetReference.fromJson(json);
+        checkTargetReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/forwardingRules/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/forwardingRules/"));
+        pathOffset += 24;
+        index = path.indexOf("/setTarget", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/setTarget"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setTarget(arg_request, arg_project, arg_forwardingRule).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-GlobalOperationsResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOperations;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/operations", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.equals("/aggregated/operations"));
+        pathOffset += 22;
+
+        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["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(buildOperationAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationAggregatedList response) {
+        checkOperationAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOperations;
+      var arg_project = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/global/operations/"));
+        pathOffset += 19;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_project, arg_operation).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOperations;
+      var arg_project = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/global/operations/"));
+        pathOffset += 19;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.get(arg_project, arg_operation).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOperations;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/operations", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/operations"));
+        pathOffset += 18;
+
+        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["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(buildOperationList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationList response) {
+        checkOperationList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-HttpHealthChecksResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_project = "foo";
+      var arg_httpHealthCheck = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/httpHealthChecks/"));
+        pathOffset += 25;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_project = "foo";
+      var arg_httpHealthCheck = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/httpHealthChecks/"));
+        pathOffset += 25;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildHttpHealthCheck());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((api.HttpHealthCheck response) {
+        checkHttpHealthCheck(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_request = buildHttpHealthCheck();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.HttpHealthCheck.fromJson(json);
+        checkHttpHealthCheck(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/httpHealthChecks"));
+        pathOffset += 24;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/global/httpHealthChecks"));
+        pathOffset += 24;
+
+        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["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(buildHttpHealthCheckList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.HttpHealthCheckList response) {
+        checkHttpHealthCheckList(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_request = buildHttpHealthCheck();
+      var arg_project = "foo";
+      var arg_httpHealthCheck = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.HttpHealthCheck.fromJson(json);
+        checkHttpHealthCheck(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/httpHealthChecks/"));
+        pathOffset += 25;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.patch(arg_request, arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthChecks;
+      var arg_request = buildHttpHealthCheck();
+      var arg_project = "foo";
+      var arg_httpHealthCheck = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.HttpHealthCheck.fromJson(json);
+        checkHttpHealthCheck(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/httpHealthChecks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/httpHealthChecks/"));
+        pathOffset += 25;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.update(arg_request, arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ImagesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ImagesResourceApi res = new api.ComputeApi(mock).images;
+      var arg_project = "foo";
+      var arg_image = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/images/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/images/"));
+        pathOffset += 15;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_image"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_image).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--deprecate", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ImagesResourceApi res = new api.ComputeApi(mock).images;
+      var arg_request = buildDeprecationStatus();
+      var arg_project = "foo";
+      var arg_image = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.DeprecationStatus.fromJson(json);
+        checkDeprecationStatus(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/images/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/images/"));
+        pathOffset += 15;
+        index = path.indexOf("/deprecate", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_image"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/deprecate"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.deprecate(arg_request, arg_project, arg_image).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ImagesResourceApi res = new api.ComputeApi(mock).images;
+      var arg_project = "foo";
+      var arg_image = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/images/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/images/"));
+        pathOffset += 15;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_image"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildImage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_image).then(unittest.expectAsync(((api.Image response) {
+        checkImage(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ImagesResourceApi res = new api.ComputeApi(mock).images;
+      var arg_request = buildImage();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Image.fromJson(json);
+        checkImage(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/images", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/global/images"));
+        pathOffset += 14;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ImagesResourceApi res = new api.ComputeApi(mock).images;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/images", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/global/images"));
+        pathOffset += 14;
+
+        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["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(buildImageList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ImageList response) {
+        checkImageList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-InstancesResourceApi", () {
+    unittest.test("method--addAccessConfig", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildAccessConfig();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      var arg_networkInterface = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.AccessConfig.fromJson(json);
+        checkAccessConfig(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/addAccessConfig", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/addAccessConfig"));
+        pathOffset += 16;
+
+        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["networkInterface"].first, unittest.equals(arg_networkInterface));
+
+
+        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));
+      }), true);
+      res.addAccessConfig(arg_request, arg_project, arg_zone, arg_instance, arg_networkInterface).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/instances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/aggregated/instances"));
+        pathOffset += 21;
+
+        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["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(buildInstanceAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.InstanceAggregatedList response) {
+        checkInstanceAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--attachDisk", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildAttachedDisk();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.AttachedDisk.fromJson(json);
+        checkAttachedDisk(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/attachDisk", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/attachDisk"));
+        pathOffset += 11;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.attachDisk(arg_request, arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--deleteAccessConfig", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      var arg_accessConfig = "foo";
+      var arg_networkInterface = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/deleteAccessConfig", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/deleteAccessConfig"));
+        pathOffset += 19;
+
+        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["accessConfig"].first, unittest.equals(arg_accessConfig));
+        unittest.expect(queryMap["networkInterface"].first, unittest.equals(arg_networkInterface));
+
+
+        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));
+      }), true);
+      res.deleteAccessConfig(arg_project, arg_zone, arg_instance, arg_accessConfig, arg_networkInterface).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--detachDisk", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      var arg_deviceName = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/detachDisk", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/detachDisk"));
+        pathOffset += 11;
+
+        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["deviceName"].first, unittest.equals(arg_deviceName));
+
+
+        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));
+      }), true);
+      res.detachDisk(arg_project, arg_zone, arg_instance, arg_deviceName).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildInstance());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Instance response) {
+        checkInstance(response);
+      })));
+    });
+
+    unittest.test("method--getSerialPortOutput", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/serialPort", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/serialPort"));
+        pathOffset += 11;
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildSerialPortOutput());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.getSerialPortOutput(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.SerialPortOutput response) {
+        checkSerialPortOutput(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildInstance();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Instance.fromJson(json);
+        checkInstance(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/instances"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), 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();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/instances"));
+        pathOffset += 10;
+
+        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["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(buildInstanceList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.InstanceList response) {
+        checkInstanceList(response);
+      })));
+    });
+
+    unittest.test("method--reset", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/reset", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/reset"));
+        pathOffset += 6;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.reset(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setDiskAutoDelete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      var arg_autoDelete = true;
+      var arg_deviceName = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/setDiskAutoDelete", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/setDiskAutoDelete"));
+        pathOffset += 18;
+
+        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["autoDelete"].first, unittest.equals("$arg_autoDelete"));
+        unittest.expect(queryMap["deviceName"].first, unittest.equals(arg_deviceName));
+
+
+        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));
+      }), true);
+      res.setDiskAutoDelete(arg_project, arg_zone, arg_instance, arg_autoDelete, arg_deviceName).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setMetadata", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildMetadata();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Metadata.fromJson(json);
+        checkMetadata(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/setMetadata", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/setMetadata"));
+        pathOffset += 12;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setMetadata(arg_request, arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setScheduling", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildScheduling();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Scheduling.fromJson(json);
+        checkScheduling(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/setScheduling", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/setScheduling"));
+        pathOffset += 14;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setScheduling(arg_request, arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setTags", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.InstancesResourceApi res = new api.ComputeApi(mock).instances;
+      var arg_request = buildTags();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_instance = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Tags.fromJson(json);
+        checkTags(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/instances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/instances/"));
+        pathOffset += 11;
+        index = path.indexOf("/setTags", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_instance"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/setTags"));
+        pathOffset += 8;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setTags(arg_request, arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-LicensesResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.LicensesResourceApi res = new api.ComputeApi(mock).licenses;
+      var arg_project = "foo";
+      var arg_license = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/licenses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/licenses/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_license"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildLicense());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_license).then(unittest.expectAsync(((api.License response) {
+        checkLicense(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-MachineTypesResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/machineTypes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.equals("/aggregated/machineTypes"));
+        pathOffset += 24;
+
+        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["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(buildMachineTypeAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.MachineTypeAggregatedList response) {
+        checkMachineTypeAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_machineType = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/machineTypes/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/machineTypes/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_machineType"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMachineType());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone, arg_machineType).then(unittest.expectAsync(((api.MachineType response) {
+        checkMachineType(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/machineTypes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/machineTypes"));
+        pathOffset += 13;
+
+        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["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(buildMachineTypeList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.MachineTypeList response) {
+        checkMachineTypeList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-NetworksResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.NetworksResourceApi res = new api.ComputeApi(mock).networks;
+      var arg_project = "foo";
+      var arg_network = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/networks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/networks/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_network"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_network).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.NetworksResourceApi res = new api.ComputeApi(mock).networks;
+      var arg_project = "foo";
+      var arg_network = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/networks/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/networks/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_network"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildNetwork());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_network).then(unittest.expectAsync(((api.Network response) {
+        checkNetwork(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.NetworksResourceApi res = new api.ComputeApi(mock).networks;
+      var arg_request = buildNetwork();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Network.fromJson(json);
+        checkNetwork(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/networks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/networks"));
+        pathOffset += 16;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.NetworksResourceApi res = new api.ComputeApi(mock).networks;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/networks", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/networks"));
+        pathOffset += 16;
+
+        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["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(buildNetworkList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.NetworkList response) {
+        checkNetworkList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ProjectsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;
+      var arg_project = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildProject());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project).then(unittest.expectAsync(((api.Project response) {
+        checkProject(response);
+      })));
+    });
+
+    unittest.test("method--setCommonInstanceMetadata", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;
+      var arg_request = buildMetadata();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Metadata.fromJson(json);
+        checkMetadata(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/setCommonInstanceMetadata", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.equals("/setCommonInstanceMetadata"));
+        pathOffset += 26;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setCommonInstanceMetadata(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setUsageExportBucket", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;
+      var arg_request = buildUsageExportLocation();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UsageExportLocation.fromJson(json);
+        checkUsageExportLocation(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/setUsageExportBucket", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/setUsageExportBucket"));
+        pathOffset += 21;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setUsageExportBucket(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-RegionOperationsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOperations;
+      var arg_project = "foo";
+      var arg_region = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/operations/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_project, arg_region, arg_operation).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOperations;
+      var arg_project = "foo";
+      var arg_region = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/operations/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.get(arg_project, arg_region, arg_operation).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOperations;
+      var arg_project = "foo";
+      var arg_region = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/operations", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/operations"));
+        pathOffset += 11;
+
+        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["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(buildOperationList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationList response) {
+        checkOperationList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-RegionsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RegionsResourceApi res = new api.ComputeApi(mock).regions;
+      var arg_project = "foo";
+      var arg_region = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildRegion());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_region).then(unittest.expectAsync(((api.Region response) {
+        checkRegion(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RegionsResourceApi res = new api.ComputeApi(mock).regions;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/regions"));
+        pathOffset += 8;
+
+        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["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(buildRegionList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.RegionList response) {
+        checkRegionList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-RoutesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RoutesResourceApi res = new api.ComputeApi(mock).routes;
+      var arg_project = "foo";
+      var arg_route = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/routes/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/routes/"));
+        pathOffset += 15;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_route"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_route).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RoutesResourceApi res = new api.ComputeApi(mock).routes;
+      var arg_project = "foo";
+      var arg_route = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/routes/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/routes/"));
+        pathOffset += 15;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_route"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildRoute());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_route).then(unittest.expectAsync(((api.Route response) {
+        checkRoute(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RoutesResourceApi res = new api.ComputeApi(mock).routes;
+      var arg_request = buildRoute();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Route.fromJson(json);
+        checkRoute(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/routes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/global/routes"));
+        pathOffset += 14;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.RoutesResourceApi res = new api.ComputeApi(mock).routes;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/routes", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/global/routes"));
+        pathOffset += 14;
+
+        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["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(buildRouteList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.RouteList response) {
+        checkRouteList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-SnapshotsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;
+      var arg_project = "foo";
+      var arg_snapshot = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/snapshots/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/snapshots/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_snapshot"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_snapshot).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;
+      var arg_project = "foo";
+      var arg_snapshot = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/snapshots/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/global/snapshots/"));
+        pathOffset += 18;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_snapshot"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildSnapshot());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_snapshot).then(unittest.expectAsync(((api.Snapshot response) {
+        checkSnapshot(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/snapshots", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/global/snapshots"));
+        pathOffset += 17;
+
+        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["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(buildSnapshotList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.SnapshotList response) {
+        checkSnapshotList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-TargetHttpProxiesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttpProxies;
+      var arg_project = "foo";
+      var arg_targetHttpProxy = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/targetHttpProxies/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.equals("/global/targetHttpProxies/"));
+        pathOffset += 26;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_targetHttpProxy).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttpProxies;
+      var arg_project = "foo";
+      var arg_targetHttpProxy = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/targetHttpProxies/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.equals("/global/targetHttpProxies/"));
+        pathOffset += 26;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildTargetHttpProxy());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_targetHttpProxy).then(unittest.expectAsync(((api.TargetHttpProxy response) {
+        checkTargetHttpProxy(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttpProxies;
+      var arg_request = buildTargetHttpProxy();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetHttpProxy.fromJson(json);
+        checkTargetHttpProxy(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/targetHttpProxies", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/targetHttpProxies"));
+        pathOffset += 25;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttpProxies;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/targetHttpProxies", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("/global/targetHttpProxies"));
+        pathOffset += 25;
+
+        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["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(buildTargetHttpProxyList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetHttpProxyList response) {
+        checkTargetHttpProxyList(response);
+      })));
+    });
+
+    unittest.test("method--setUrlMap", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttpProxies;
+      var arg_request = buildUrlMapReference();
+      var arg_project = "foo";
+      var arg_targetHttpProxy = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UrlMapReference.fromJson(json);
+        checkUrlMapReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/targetHttpProxies/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("/targetHttpProxies/"));
+        pathOffset += 19;
+        index = path.indexOf("/setUrlMap", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/setUrlMap"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.setUrlMap(arg_request, arg_project, arg_targetHttpProxy).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-TargetInstancesResourceApi", () {
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstances;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/targetInstances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.equals("/aggregated/targetInstances"));
+        pathOffset += 27;
+
+        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["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(buildTargetInstanceAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetInstanceAggregatedList response) {
+        checkTargetInstanceAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_targetInstance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/targetInstances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/targetInstances/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetInstance"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_zone, arg_targetInstance).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstances;
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      var arg_targetInstance = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/targetInstances/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("/targetInstances/"));
+        pathOffset += 17;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetInstance"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildTargetInstance());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone, arg_targetInstance).then(unittest.expectAsync(((api.TargetInstance response) {
+        checkTargetInstance(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstances;
+      var arg_request = buildTargetInstance();
+      var arg_project = "foo";
+      var arg_zone = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetInstance.fromJson(json);
+        checkTargetInstance(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/targetInstances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/targetInstances"));
+        pathOffset += 16;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), 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();
+      api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstances;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/targetInstances", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/targetInstances"));
+        pathOffset += 16;
+
+        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["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(buildTargetInstanceList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetInstanceList response) {
+        checkTargetInstanceList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-TargetPoolsResourceApi", () {
+    unittest.test("method--addHealthCheck", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetPoolsAddHealthCheckRequest();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetPoolsAddHealthCheckRequest.fromJson(json);
+        checkTargetPoolsAddHealthCheckRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/addHealthCheck", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/addHealthCheck"));
+        pathOffset += 15;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.addHealthCheck(arg_request, arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--addInstance", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetPoolsAddInstanceRequest();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetPoolsAddInstanceRequest.fromJson(json);
+        checkTargetPoolsAddInstanceRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/addInstance", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/addInstance"));
+        pathOffset += 12;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.addInstance(arg_request, arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--aggregatedList", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/aggregated/targetPools", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("/aggregated/targetPools"));
+        pathOffset += 23;
+
+        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["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(buildTargetPoolAggregatedList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetPoolAggregatedList response) {
+        checkTargetPoolAggregatedList(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildTargetPool());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.TargetPool response) {
+        checkTargetPool(response);
+      })));
+    });
+
+    unittest.test("method--getHealth", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildInstanceReference();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.InstanceReference.fromJson(json);
+        checkInstanceReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/getHealth", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/getHealth"));
+        pathOffset += 10;
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildTargetPoolInstanceHealth());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.getHealth(arg_request, arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.TargetPoolInstanceHealth response) {
+        checkTargetPoolInstanceHealth(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetPool();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetPool.fromJson(json);
+        checkTargetPool(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/targetPools"));
+        pathOffset += 12;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_project = "foo";
+      var arg_region = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/targetPools"));
+        pathOffset += 12;
+
+        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["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(buildTargetPoolList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetPoolList response) {
+        checkTargetPoolList(response);
+      })));
+    });
+
+    unittest.test("method--removeHealthCheck", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetPoolsRemoveHealthCheckRequest();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetPoolsRemoveHealthCheckRequest.fromJson(json);
+        checkTargetPoolsRemoveHealthCheckRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/removeHealthCheck", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("/removeHealthCheck"));
+        pathOffset += 18;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.removeHealthCheck(arg_request, arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--removeInstance", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetPoolsRemoveInstanceRequest();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetPoolsRemoveInstanceRequest.fromJson(json);
+        checkTargetPoolsRemoveInstanceRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/removeInstance", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/removeInstance"));
+        pathOffset += 15;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.removeInstance(arg_request, arg_project, arg_region, arg_targetPool).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--setBackup", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;
+      var arg_request = buildTargetReference();
+      var arg_project = "foo";
+      var arg_region = "foo";
+      var arg_targetPool = "foo";
+      var arg_failoverRatio = 42.0;
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.TargetReference.fromJson(json);
+        checkTargetReference(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/regions/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/regions/"));
+        pathOffset += 9;
+        index = path.indexOf("/targetPools/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_region"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/targetPools/"));
+        pathOffset += 13;
+        index = path.indexOf("/setBackup", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_targetPool"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/setBackup"));
+        pathOffset += 10;
+
+        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(core.num.parse(queryMap["failoverRatio"].first), unittest.equals(arg_failoverRatio));
+
+
+        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));
+      }), true);
+      res.setBackup(arg_request, arg_project, arg_region, arg_targetPool, failoverRatio: arg_failoverRatio).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UrlMapsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_project = "foo";
+      var arg_urlMap = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/urlMaps/"));
+        pathOffset += 16;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_urlMap"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.delete(arg_project, arg_urlMap).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_project = "foo";
+      var arg_urlMap = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/urlMaps/"));
+        pathOffset += 16;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_urlMap"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUrlMap());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_urlMap).then(unittest.expectAsync(((api.UrlMap response) {
+        checkUrlMap(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_request = buildUrlMap();
+      var arg_project = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UrlMap.fromJson(json);
+        checkUrlMap(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/urlMaps"));
+        pathOffset += 15;
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/global/urlMaps"));
+        pathOffset += 15;
+
+        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["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(buildUrlMapList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.UrlMapList response) {
+        checkUrlMapList(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_request = buildUrlMap();
+      var arg_project = "foo";
+      var arg_urlMap = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UrlMap.fromJson(json);
+        checkUrlMap(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/urlMaps/"));
+        pathOffset += 16;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_urlMap"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.patch(arg_request, arg_project, arg_urlMap).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_request = buildUrlMap();
+      var arg_project = "foo";
+      var arg_urlMap = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UrlMap.fromJson(json);
+        checkUrlMap(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/urlMaps/"));
+        pathOffset += 16;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_urlMap"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.update(arg_request, arg_project, arg_urlMap).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--validate", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;
+      var arg_request = buildUrlMapsValidateRequest();
+      var arg_project = "foo";
+      var arg_urlMap = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.UrlMapsValidateRequest.fromJson(json);
+        checkUrlMapsValidateRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/global/urlMaps/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/global/urlMaps/"));
+        pathOffset += 16;
+        index = path.indexOf("/validate", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_urlMap"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/validate"));
+        pathOffset += 9;
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUrlMapsValidateResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.validate(arg_request, arg_project, arg_urlMap).then(unittest.expectAsync(((api.UrlMapsValidateResponse response) {
+        checkUrlMapsValidateResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ZoneOperationsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ZoneOperationsResourceApi res = new api.ComputeApi(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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/operations/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_project, arg_zone, arg_operation).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ZoneOperationsResourceApi res = new api.ComputeApi(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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/operations/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/operations/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_operation"));
+
+        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]));
+          }
+        }
+
+
+        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));
+      }), true);
+      res.get(arg_project, arg_zone, arg_operation).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ZoneOperationsResourceApi res = new api.ComputeApi(mock).zoneOperations;
+      var arg_project = "foo";
+      var arg_zone = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        index = path.indexOf("/operations", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("/operations"));
+        pathOffset += 11;
+
+        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["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(buildOperationList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationList response) {
+        checkOperationList(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ZonesResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ZonesResourceApi res = new api.ComputeApi(mock).zones;
+      var arg_project = "foo";
+      var arg_zone = "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 + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/zones/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_zone"));
+
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildZone());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_project, arg_zone).then(unittest.expectAsync(((api.Zone response) {
+        checkZone(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.ZonesResourceApi res = new api.ComputeApi(mock).zones;
+      var arg_project = "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;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("/compute/v1/projects/"));
+        pathOffset += 21;
+        index = path.indexOf("/zones", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_project"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/zones"));
+        pathOffset += 6;
+
+        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["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(buildZoneList());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ZoneList response) {
+        checkZoneList(response);
+      })));
+    });
+
+  });
+
+
+}
+