Api-roll 39: 2016-07-18

generated/googleapis/test/cloudbuild/v1_test.dart

Index: generated/googleapis/test/cloudbuild/v1_test.dart
diff --git a/generated/googleapis/test/cloudbuild/v1_test.dart b/generated/googleapis/test/cloudbuild/v1_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..7469c3f0d1c68d566046afe59da4ea5d618860a7
--- /dev/null
+++ b/generated/googleapis/test/cloudbuild/v1_test.dart
@@ -0,0 +1,1077 @@
+library googleapis.cloudbuild.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/cloudbuild/v1.dart' as api;
+
+class HttpServerMock extends http.BaseClient {
+  core.Function _callback;
+  core.bool _expectJson;
+
+  void register(core.Function callback, core.bool expectJson) {
+    _callback = callback;
+    _expectJson = expectJson;
+  }
+
+  async.Future<http.StreamedResponse> send(http.BaseRequest request) {
+    if (_expectJson) {
+      return request.finalize()
+          .transform(convert.UTF8.decoder)
+          .join('')
+          .then((core.String jsonString) {
+        if (jsonString.isEmpty) {
+          return _callback(request, null);
+        } else {
+          return _callback(request, convert.JSON.decode(jsonString));
+        }
+      });
+    } else {
+      var stream = request.finalize();
+      if (stream == null) {
+        return _callback(request, []);
+      } else {
+        return stream.toBytes().then((data) {
+          return _callback(request, data);
+        });
+      }
+    }
+  }
+}
+
+http.StreamedResponse stringResponse(
+    core.int status, core.Map headers, core.String body) {
+  var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
+  return new http.StreamedResponse(stream, status, headers: headers);
+}
+
+buildUnnamed1286() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1286(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'));
+}
+
+buildUnnamed1287() {
+  var o = new core.List<api.BuildStep>();
+  o.add(buildBuildStep());
+  o.add(buildBuildStep());
+  return o;
+}
+
+checkUnnamed1287(core.List<api.BuildStep> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBuildStep(o[0]);
+  checkBuildStep(o[1]);
+}
+
+core.int buildCounterBuild = 0;
+buildBuild() {
+  var o = new api.Build();
+  buildCounterBuild++;
+  if (buildCounterBuild < 3) {
+    o.createTime = "foo";
+    o.finishTime = "foo";
+    o.id = "foo";
+    o.images = buildUnnamed1286();
+    o.logsBucket = "foo";
+    o.options = buildBuildOptions();
+    o.projectId = "foo";
+    o.results = buildResults();
+    o.source = buildSource();
+    o.sourceProvenance = buildSourceProvenance();
+    o.startTime = "foo";
+    o.status = "foo";
+    o.statusDetail = "foo";
+    o.steps = buildUnnamed1287();
+    o.timeout = "foo";
+  }
+  buildCounterBuild--;
+  return o;
+}
+
+checkBuild(api.Build o) {
+  buildCounterBuild++;
+  if (buildCounterBuild < 3) {
+    unittest.expect(o.createTime, unittest.equals('foo'));
+    unittest.expect(o.finishTime, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed1286(o.images);
+    unittest.expect(o.logsBucket, unittest.equals('foo'));
+    checkBuildOptions(o.options);
+    unittest.expect(o.projectId, unittest.equals('foo'));
+    checkResults(o.results);
+    checkSource(o.source);
+    checkSourceProvenance(o.sourceProvenance);
+    unittest.expect(o.startTime, unittest.equals('foo'));
+    unittest.expect(o.status, unittest.equals('foo'));
+    unittest.expect(o.statusDetail, unittest.equals('foo'));
+    checkUnnamed1287(o.steps);
+    unittest.expect(o.timeout, unittest.equals('foo'));
+  }
+  buildCounterBuild--;
+}
+
+core.int buildCounterBuildOperationMetadata = 0;
+buildBuildOperationMetadata() {
+  var o = new api.BuildOperationMetadata();
+  buildCounterBuildOperationMetadata++;
+  if (buildCounterBuildOperationMetadata < 3) {
+    o.build = buildBuild();
+  }
+  buildCounterBuildOperationMetadata--;
+  return o;
+}
+
+checkBuildOperationMetadata(api.BuildOperationMetadata o) {
+  buildCounterBuildOperationMetadata++;
+  if (buildCounterBuildOperationMetadata < 3) {
+    checkBuild(o.build);
+  }
+  buildCounterBuildOperationMetadata--;
+}
+
+buildUnnamed1288() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1288(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 buildCounterBuildOptions = 0;
+buildBuildOptions() {
+  var o = new api.BuildOptions();
+  buildCounterBuildOptions++;
+  if (buildCounterBuildOptions < 3) {
+    o.requestedVerifyOption = "foo";
+    o.sourceProvenanceHash = buildUnnamed1288();
+  }
+  buildCounterBuildOptions--;
+  return o;
+}
+
+checkBuildOptions(api.BuildOptions o) {
+  buildCounterBuildOptions++;
+  if (buildCounterBuildOptions < 3) {
+    unittest.expect(o.requestedVerifyOption, unittest.equals('foo'));
+    checkUnnamed1288(o.sourceProvenanceHash);
+  }
+  buildCounterBuildOptions--;
+}
+
+buildUnnamed1289() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1289(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'));
+}
+
+buildUnnamed1290() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1290(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 buildCounterBuildStep = 0;
+buildBuildStep() {
+  var o = new api.BuildStep();
+  buildCounterBuildStep++;
+  if (buildCounterBuildStep < 3) {
+    o.args = buildUnnamed1289();
+    o.dir = "foo";
+    o.env = buildUnnamed1290();
+    o.name = "foo";
+  }
+  buildCounterBuildStep--;
+  return o;
+}
+
+checkBuildStep(api.BuildStep o) {
+  buildCounterBuildStep++;
+  if (buildCounterBuildStep < 3) {
+    checkUnnamed1289(o.args);
+    unittest.expect(o.dir, unittest.equals('foo'));
+    checkUnnamed1290(o.env);
+    unittest.expect(o.name, unittest.equals('foo'));
+  }
+  buildCounterBuildStep--;
+}
+
+core.int buildCounterBuiltImage = 0;
+buildBuiltImage() {
+  var o = new api.BuiltImage();
+  buildCounterBuiltImage++;
+  if (buildCounterBuiltImage < 3) {
+    o.digest = "foo";
+    o.name = "foo";
+  }
+  buildCounterBuiltImage--;
+  return o;
+}
+
+checkBuiltImage(api.BuiltImage o) {
+  buildCounterBuiltImage++;
+  if (buildCounterBuiltImage < 3) {
+    unittest.expect(o.digest, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+  }
+  buildCounterBuiltImage--;
+}
+
+core.int buildCounterCancelBuildRequest = 0;
+buildCancelBuildRequest() {
+  var o = new api.CancelBuildRequest();
+  buildCounterCancelBuildRequest++;
+  if (buildCounterCancelBuildRequest < 3) {
+  }
+  buildCounterCancelBuildRequest--;
+  return o;
+}
+
+checkCancelBuildRequest(api.CancelBuildRequest o) {
+  buildCounterCancelBuildRequest++;
+  if (buildCounterCancelBuildRequest < 3) {
+  }
+  buildCounterCancelBuildRequest--;
+}
+
+buildUnnamed1291() {
+  var o = new core.List<api.Hash>();
+  o.add(buildHash());
+  o.add(buildHash());
+  return o;
+}
+
+checkUnnamed1291(core.List<api.Hash> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHash(o[0]);
+  checkHash(o[1]);
+}
+
+core.int buildCounterFileHashes = 0;
+buildFileHashes() {
+  var o = new api.FileHashes();
+  buildCounterFileHashes++;
+  if (buildCounterFileHashes < 3) {
+    o.fileHash = buildUnnamed1291();
+  }
+  buildCounterFileHashes--;
+  return o;
+}
+
+checkFileHashes(api.FileHashes o) {
+  buildCounterFileHashes++;
+  if (buildCounterFileHashes < 3) {
+    checkUnnamed1291(o.fileHash);
+  }
+  buildCounterFileHashes--;
+}
+
+core.int buildCounterHash = 0;
+buildHash() {
+  var o = new api.Hash();
+  buildCounterHash++;
+  if (buildCounterHash < 3) {
+    o.type = "foo";
+    o.value = "foo";
+  }
+  buildCounterHash--;
+  return o;
+}
+
+checkHash(api.Hash o) {
+  buildCounterHash++;
+  if (buildCounterHash < 3) {
+    unittest.expect(o.type, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterHash--;
+}
+
+buildUnnamed1292() {
+  var o = new core.List<api.Build>();
+  o.add(buildBuild());
+  o.add(buildBuild());
+  return o;
+}
+
+checkUnnamed1292(core.List<api.Build> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBuild(o[0]);
+  checkBuild(o[1]);
+}
+
+core.int buildCounterListBuildsResponse = 0;
+buildListBuildsResponse() {
+  var o = new api.ListBuildsResponse();
+  buildCounterListBuildsResponse++;
+  if (buildCounterListBuildsResponse < 3) {
+    o.builds = buildUnnamed1292();
+    o.nextPageToken = "foo";
+  }
+  buildCounterListBuildsResponse--;
+  return o;
+}
+
+checkListBuildsResponse(api.ListBuildsResponse o) {
+  buildCounterListBuildsResponse++;
+  if (buildCounterListBuildsResponse < 3) {
+    checkUnnamed1292(o.builds);
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+  }
+  buildCounterListBuildsResponse--;
+}
+
+buildUnnamed1293() {
+  var o = new core.List<api.Operation>();
+  o.add(buildOperation());
+  o.add(buildOperation());
+  return o;
+}
+
+checkUnnamed1293(core.List<api.Operation> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkOperation(o[0]);
+  checkOperation(o[1]);
+}
+
+core.int buildCounterListOperationsResponse = 0;
+buildListOperationsResponse() {
+  var o = new api.ListOperationsResponse();
+  buildCounterListOperationsResponse++;
+  if (buildCounterListOperationsResponse < 3) {
+    o.nextPageToken = "foo";
+    o.operations = buildUnnamed1293();
+  }
+  buildCounterListOperationsResponse--;
+  return o;
+}
+
+checkListOperationsResponse(api.ListOperationsResponse o) {
+  buildCounterListOperationsResponse++;
+  if (buildCounterListOperationsResponse < 3) {
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    checkUnnamed1293(o.operations);
+  }
+  buildCounterListOperationsResponse--;
+}
+
+buildUnnamed1294() {
+  var o = new core.Map<core.String, core.Object>();
+  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  return o;
+}
+
+checkUnnamed1294(core.Map<core.String, core.Object> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  var casted1 = (o["x"]) as core.Map; unittest.expect(casted1, unittest.hasLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], unittest.equals('foo')); 
+  var casted2 = (o["y"]) as core.Map; unittest.expect(casted2, unittest.hasLength(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], unittest.equals('foo')); 
+}
+
+buildUnnamed1295() {
+  var o = new core.Map<core.String, core.Object>();
+  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  return o;
+}
+
+checkUnnamed1295(core.Map<core.String, core.Object> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  var casted3 = (o["x"]) as core.Map; unittest.expect(casted3, unittest.hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo')); 
+  var casted4 = (o["y"]) as core.Map; unittest.expect(casted4, unittest.hasLength(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], unittest.equals('foo')); 
+}
+
+core.int buildCounterOperation = 0;
+buildOperation() {
+  var o = new api.Operation();
+  buildCounterOperation++;
+  if (buildCounterOperation < 3) {
+    o.done = true;
+    o.error = buildStatus();
+    o.metadata = buildUnnamed1294();
+    o.name = "foo";
+    o.response = buildUnnamed1295();
+  }
+  buildCounterOperation--;
+  return o;
+}
+
+checkOperation(api.Operation o) {
+  buildCounterOperation++;
+  if (buildCounterOperation < 3) {
+    unittest.expect(o.done, unittest.isTrue);
+    checkStatus(o.error);
+    checkUnnamed1294(o.metadata);
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed1295(o.response);
+  }
+  buildCounterOperation--;
+}
+
+buildUnnamed1296() {
+  var o = new core.List<api.BuiltImage>();
+  o.add(buildBuiltImage());
+  o.add(buildBuiltImage());
+  return o;
+}
+
+checkUnnamed1296(core.List<api.BuiltImage> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkBuiltImage(o[0]);
+  checkBuiltImage(o[1]);
+}
+
+core.int buildCounterResults = 0;
+buildResults() {
+  var o = new api.Results();
+  buildCounterResults++;
+  if (buildCounterResults < 3) {
+    o.images = buildUnnamed1296();
+  }
+  buildCounterResults--;
+  return o;
+}
+
+checkResults(api.Results o) {
+  buildCounterResults++;
+  if (buildCounterResults < 3) {
+    checkUnnamed1296(o.images);
+  }
+  buildCounterResults--;
+}
+
+core.int buildCounterSource = 0;
+buildSource() {
+  var o = new api.Source();
+  buildCounterSource++;
+  if (buildCounterSource < 3) {
+    o.storageSource = buildStorageSource();
+  }
+  buildCounterSource--;
+  return o;
+}
+
+checkSource(api.Source o) {
+  buildCounterSource++;
+  if (buildCounterSource < 3) {
+    checkStorageSource(o.storageSource);
+  }
+  buildCounterSource--;
+}
+
+buildUnnamed1297() {
+  var o = new core.Map<core.String, api.FileHashes>();
+  o["x"] = buildFileHashes();
+  o["y"] = buildFileHashes();
+  return o;
+}
+
+checkUnnamed1297(core.Map<core.String, api.FileHashes> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkFileHashes(o["x"]);
+  checkFileHashes(o["y"]);
+}
+
+core.int buildCounterSourceProvenance = 0;
+buildSourceProvenance() {
+  var o = new api.SourceProvenance();
+  buildCounterSourceProvenance++;
+  if (buildCounterSourceProvenance < 3) {
+    o.fileHashes = buildUnnamed1297();
+  }
+  buildCounterSourceProvenance--;
+  return o;
+}
+
+checkSourceProvenance(api.SourceProvenance o) {
+  buildCounterSourceProvenance++;
+  if (buildCounterSourceProvenance < 3) {
+    checkUnnamed1297(o.fileHashes);
+  }
+  buildCounterSourceProvenance--;
+}
+
+buildUnnamed1298() {
+  var o = new core.Map<core.String, core.Object>();
+  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  return o;
+}
+
+checkUnnamed1298(core.Map<core.String, core.Object> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  var casted5 = (o["x"]) as core.Map; unittest.expect(casted5, unittest.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], unittest.equals('foo')); 
+  var casted6 = (o["y"]) as core.Map; unittest.expect(casted6, unittest.hasLength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittest.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["string"], unittest.equals('foo')); 
+}
+
+buildUnnamed1299() {
+  var o = new core.List<core.Map<core.String, core.Object>>();
+  o.add(buildUnnamed1298());
+  o.add(buildUnnamed1298());
+  return o;
+}
+
+checkUnnamed1299(core.List<core.Map<core.String, core.Object>> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUnnamed1298(o[0]);
+  checkUnnamed1298(o[1]);
+}
+
+core.int buildCounterStatus = 0;
+buildStatus() {
+  var o = new api.Status();
+  buildCounterStatus++;
+  if (buildCounterStatus < 3) {
+    o.code = 42;
+    o.details = buildUnnamed1299();
+    o.message = "foo";
+  }
+  buildCounterStatus--;
+  return o;
+}
+
+checkStatus(api.Status o) {
+  buildCounterStatus++;
+  if (buildCounterStatus < 3) {
+    unittest.expect(o.code, unittest.equals(42));
+    checkUnnamed1299(o.details);
+    unittest.expect(o.message, unittest.equals('foo'));
+  }
+  buildCounterStatus--;
+}
+
+core.int buildCounterStorageSource = 0;
+buildStorageSource() {
+  var o = new api.StorageSource();
+  buildCounterStorageSource++;
+  if (buildCounterStorageSource < 3) {
+    o.bucket = "foo";
+    o.generation = "foo";
+    o.object = "foo";
+  }
+  buildCounterStorageSource--;
+  return o;
+}
+
+checkStorageSource(api.StorageSource o) {
+  buildCounterStorageSource++;
+  if (buildCounterStorageSource < 3) {
+    unittest.expect(o.bucket, unittest.equals('foo'));
+    unittest.expect(o.generation, unittest.equals('foo'));
+    unittest.expect(o.object, unittest.equals('foo'));
+  }
+  buildCounterStorageSource--;
+}
+
+
+main() {
+  unittest.group("obj-schema-Build", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBuild();
+      var od = new api.Build.fromJson(o.toJson());
+      checkBuild(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BuildOperationMetadata", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBuildOperationMetadata();
+      var od = new api.BuildOperationMetadata.fromJson(o.toJson());
+      checkBuildOperationMetadata(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BuildOptions", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBuildOptions();
+      var od = new api.BuildOptions.fromJson(o.toJson());
+      checkBuildOptions(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BuildStep", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBuildStep();
+      var od = new api.BuildStep.fromJson(o.toJson());
+      checkBuildStep(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-BuiltImage", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildBuiltImage();
+      var od = new api.BuiltImage.fromJson(o.toJson());
+      checkBuiltImage(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-CancelBuildRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCancelBuildRequest();
+      var od = new api.CancelBuildRequest.fromJson(o.toJson());
+      checkCancelBuildRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-FileHashes", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildFileHashes();
+      var od = new api.FileHashes.fromJson(o.toJson());
+      checkFileHashes(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Hash", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHash();
+      var od = new api.Hash.fromJson(o.toJson());
+      checkHash(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListBuildsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListBuildsResponse();
+      var od = new api.ListBuildsResponse.fromJson(o.toJson());
+      checkListBuildsResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListOperationsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListOperationsResponse();
+      var od = new api.ListOperationsResponse.fromJson(o.toJson());
+      checkListOperationsResponse(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-Results", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildResults();
+      var od = new api.Results.fromJson(o.toJson());
+      checkResults(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Source", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSource();
+      var od = new api.Source.fromJson(o.toJson());
+      checkSource(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-SourceProvenance", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildSourceProvenance();
+      var od = new api.SourceProvenance.fromJson(o.toJson());
+      checkSourceProvenance(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Status", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildStatus();
+      var od = new api.Status.fromJson(o.toJson());
+      checkStatus(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-StorageSource", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildStorageSource();
+      var od = new api.StorageSource.fromJson(o.toJson());
+      checkStorageSource(od);
+    });
+  });
+
+
+  unittest.group("resource-OperationsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.OperationsResourceApi res = new api.CloudbuildApi(mock).operations;
+      var arg_name = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
+        pathOffset += 3;
+        // NOTE: We cannot test reserved expansions due to the inability to reverse the 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(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_name).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.OperationsResourceApi res = new api.CloudbuildApi(mock).operations;
+      var arg_name = "foo";
+      var arg_pageSize = 42;
+      var arg_filter = "foo";
+      var arg_pageToken = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
+        pathOffset += 3;
+        // NOTE: We cannot test reserved expansions due to the inability to reverse the 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]));
+          }
+        }
+        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListOperationsResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_name, pageSize: arg_pageSize, filter: arg_filter, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListOperationsResponse response) {
+        checkListOperationsResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ProjectsBuildsResourceApi", () {
+    unittest.test("method--cancel", () {
+
+      var mock = new HttpServerMock();
+      api.ProjectsBuildsResourceApi res = new api.CloudbuildApi(mock).projects.builds;
+      var arg_request = buildCancelBuildRequest();
+      var arg_projectId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.CancelBuildRequest.fromJson(json);
+        checkCancelBuildRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("v1/projects/"));
+        pathOffset += 12;
+        index = path.indexOf("/builds/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_projectId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/builds/"));
+        pathOffset += 8;
+        index = path.indexOf(":cancel", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals(":cancel"));
+        pathOffset += 7;
+
+        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(buildBuild());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.cancel(arg_request, arg_projectId, arg_id).then(unittest.expectAsync(((api.Build response) {
+        checkBuild(response);
+      })));
+    });
+
+    unittest.test("method--create", () {
+
+      var mock = new HttpServerMock();
+      api.ProjectsBuildsResourceApi res = new api.CloudbuildApi(mock).projects.builds;
+      var arg_request = buildBuild();
+      var arg_projectId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Build.fromJson(json);
+        checkBuild(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("v1/projects/"));
+        pathOffset += 12;
+        index = path.indexOf("/builds", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_projectId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/builds"));
+        pathOffset += 7;
+
+        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(stringResponse(200, h, resp));
+      }), true);
+      res.create(arg_request, arg_projectId).then(unittest.expectAsync(((api.Operation response) {
+        checkOperation(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.ProjectsBuildsResourceApi res = new api.CloudbuildApi(mock).projects.builds;
+      var arg_projectId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("v1/projects/"));
+        pathOffset += 12;
+        index = path.indexOf("/builds/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_projectId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/builds/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        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(buildBuild());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_projectId, arg_id).then(unittest.expectAsync(((api.Build response) {
+        checkBuild(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.ProjectsBuildsResourceApi res = new api.CloudbuildApi(mock).projects.builds;
+      var arg_projectId = "foo";
+      var arg_pageSize = 42;
+      var arg_pageToken = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("v1/projects/"));
+        pathOffset += 12;
+        index = path.indexOf("/builds", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_projectId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/builds"));
+        pathOffset += 7;
+
+        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.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListBuildsResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_projectId, pageSize: arg_pageSize, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListBuildsResponse response) {
+        checkListBuildsResponse(response);
+      })));
+    });
+
+  });
+
+
+}
+