Api-Roll 54: 2017-09-11

generated/googleapis/test/safebrowsing/v4_test.dart

 library googleapis.safebrowsing.v4.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:test/test.dart' as unittest;
 
 import 'package:googleapis/safebrowsing/v4.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()
+      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<core.String, core.String> headers, core.String body) {
+http.StreamedResponse stringResponse(core.int status,
+    core.Map<core.String, core.String> headers, core.String body) {
   var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
   return new http.StreamedResponse(stream, status, headers: headers);
 }
 
 core.int buildCounterChecksum = 0;
 buildChecksum() {
   var o = new api.Checksum();
   buildCounterChecksum++;
   if (buildCounterChecksum < 3) {
     o.sha256 = "foo";
@@ skipping 24 matching lines @@
 
 checkClientInfo(api.ClientInfo o) {
   buildCounterClientInfo++;
   if (buildCounterClientInfo < 3) {
     unittest.expect(o.clientId, unittest.equals('foo'));
     unittest.expect(o.clientVersion, unittest.equals('foo'));
   }
   buildCounterClientInfo--;
 }
 
-buildUnnamed1081() {
+buildUnnamed1084() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1081(core.List<core.String> o) {
+checkUnnamed1084(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 buildCounterConstraints = 0;
 buildConstraints() {
   var o = new api.Constraints();
   buildCounterConstraints++;
   if (buildCounterConstraints < 3) {
     o.maxDatabaseEntries = 42;
     o.maxUpdateEntries = 42;
     o.region = "foo";
-    o.supportedCompressions = buildUnnamed1081();
+    o.supportedCompressions = buildUnnamed1084();
   }
   buildCounterConstraints--;
   return o;
 }
 
 checkConstraints(api.Constraints o) {
   buildCounterConstraints++;
   if (buildCounterConstraints < 3) {
     unittest.expect(o.maxDatabaseEntries, unittest.equals(42));
     unittest.expect(o.maxUpdateEntries, unittest.equals(42));
     unittest.expect(o.region, unittest.equals('foo'));
-    checkUnnamed1081(o.supportedCompressions);
+    checkUnnamed1084(o.supportedCompressions);
   }
   buildCounterConstraints--;
 }
 
-buildUnnamed1082() {
+buildUnnamed1085() {
   var o = new core.List<api.ListUpdateRequest>();
   o.add(buildListUpdateRequest());
   o.add(buildListUpdateRequest());
   return o;
 }
 
-checkUnnamed1082(core.List<api.ListUpdateRequest> o) {
+checkUnnamed1085(core.List<api.ListUpdateRequest> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkListUpdateRequest(o[0]);
   checkListUpdateRequest(o[1]);
 }
 
 core.int buildCounterFetchThreatListUpdatesRequest = 0;
 buildFetchThreatListUpdatesRequest() {
   var o = new api.FetchThreatListUpdatesRequest();
   buildCounterFetchThreatListUpdatesRequest++;
   if (buildCounterFetchThreatListUpdatesRequest < 3) {
     o.client = buildClientInfo();
-    o.listUpdateRequests = buildUnnamed1082();
+    o.listUpdateRequests = buildUnnamed1085();
   }
   buildCounterFetchThreatListUpdatesRequest--;
   return o;
 }
 
 checkFetchThreatListUpdatesRequest(api.FetchThreatListUpdatesRequest o) {
   buildCounterFetchThreatListUpdatesRequest++;
   if (buildCounterFetchThreatListUpdatesRequest < 3) {
     checkClientInfo(o.client);
-    checkUnnamed1082(o.listUpdateRequests);
+    checkUnnamed1085(o.listUpdateRequests);
   }
   buildCounterFetchThreatListUpdatesRequest--;
 }
 
-buildUnnamed1083() {
+buildUnnamed1086() {
   var o = new core.List<api.ListUpdateResponse>();
   o.add(buildListUpdateResponse());
   o.add(buildListUpdateResponse());
   return o;
 }
 
-checkUnnamed1083(core.List<api.ListUpdateResponse> o) {
+checkUnnamed1086(core.List<api.ListUpdateResponse> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkListUpdateResponse(o[0]);
   checkListUpdateResponse(o[1]);
 }
 
 core.int buildCounterFetchThreatListUpdatesResponse = 0;
 buildFetchThreatListUpdatesResponse() {
   var o = new api.FetchThreatListUpdatesResponse();
   buildCounterFetchThreatListUpdatesResponse++;
   if (buildCounterFetchThreatListUpdatesResponse < 3) {
-    o.listUpdateResponses = buildUnnamed1083();
+    o.listUpdateResponses = buildUnnamed1086();
     o.minimumWaitDuration = "foo";
   }
   buildCounterFetchThreatListUpdatesResponse--;
   return o;
 }
 
 checkFetchThreatListUpdatesResponse(api.FetchThreatListUpdatesResponse o) {
   buildCounterFetchThreatListUpdatesResponse++;
   if (buildCounterFetchThreatListUpdatesResponse < 3) {
-    checkUnnamed1083(o.listUpdateResponses);
+    checkUnnamed1086(o.listUpdateResponses);
     unittest.expect(o.minimumWaitDuration, unittest.equals('foo'));
   }
   buildCounterFetchThreatListUpdatesResponse--;
 }
 
-buildUnnamed1084() {
+buildUnnamed1087() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1084(core.List<core.String> o) {
+checkUnnamed1087(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 buildCounterFindFullHashesRequest = 0;
 buildFindFullHashesRequest() {
   var o = new api.FindFullHashesRequest();
   buildCounterFindFullHashesRequest++;
   if (buildCounterFindFullHashesRequest < 3) {
     o.apiClient = buildClientInfo();
     o.client = buildClientInfo();
-    o.clientStates = buildUnnamed1084();
+    o.clientStates = buildUnnamed1087();
     o.threatInfo = buildThreatInfo();
   }
   buildCounterFindFullHashesRequest--;
   return o;
 }
 
 checkFindFullHashesRequest(api.FindFullHashesRequest o) {
   buildCounterFindFullHashesRequest++;
   if (buildCounterFindFullHashesRequest < 3) {
     checkClientInfo(o.apiClient);
     checkClientInfo(o.client);
-    checkUnnamed1084(o.clientStates);
+    checkUnnamed1087(o.clientStates);
     checkThreatInfo(o.threatInfo);
   }
   buildCounterFindFullHashesRequest--;
 }
 
-buildUnnamed1085() {
+buildUnnamed1088() {
   var o = new core.List<api.ThreatMatch>();
   o.add(buildThreatMatch());
   o.add(buildThreatMatch());
   return o;
 }
 
-checkUnnamed1085(core.List<api.ThreatMatch> o) {
+checkUnnamed1088(core.List<api.ThreatMatch> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThreatMatch(o[0]);
   checkThreatMatch(o[1]);
 }
 
 core.int buildCounterFindFullHashesResponse = 0;
 buildFindFullHashesResponse() {
   var o = new api.FindFullHashesResponse();
   buildCounterFindFullHashesResponse++;
   if (buildCounterFindFullHashesResponse < 3) {
-    o.matches = buildUnnamed1085();
+    o.matches = buildUnnamed1088();
     o.minimumWaitDuration = "foo";
     o.negativeCacheDuration = "foo";
   }
   buildCounterFindFullHashesResponse--;
   return o;
 }
 
 checkFindFullHashesResponse(api.FindFullHashesResponse o) {
   buildCounterFindFullHashesResponse++;
   if (buildCounterFindFullHashesResponse < 3) {
-    checkUnnamed1085(o.matches);
+    checkUnnamed1088(o.matches);
     unittest.expect(o.minimumWaitDuration, unittest.equals('foo'));
     unittest.expect(o.negativeCacheDuration, unittest.equals('foo'));
   }
   buildCounterFindFullHashesResponse--;
 }
 
 core.int buildCounterFindThreatMatchesRequest = 0;
 buildFindThreatMatchesRequest() {
   var o = new api.FindThreatMatchesRequest();
   buildCounterFindThreatMatchesRequest++;
   if (buildCounterFindThreatMatchesRequest < 3) {
     o.client = buildClientInfo();
     o.threatInfo = buildThreatInfo();
   }
   buildCounterFindThreatMatchesRequest--;
   return o;
 }
 
 checkFindThreatMatchesRequest(api.FindThreatMatchesRequest o) {
   buildCounterFindThreatMatchesRequest++;
   if (buildCounterFindThreatMatchesRequest < 3) {
     checkClientInfo(o.client);
     checkThreatInfo(o.threatInfo);
   }
   buildCounterFindThreatMatchesRequest--;
 }
 
-buildUnnamed1086() {
+buildUnnamed1089() {
   var o = new core.List<api.ThreatMatch>();
   o.add(buildThreatMatch());
   o.add(buildThreatMatch());
   return o;
 }
 
-checkUnnamed1086(core.List<api.ThreatMatch> o) {
+checkUnnamed1089(core.List<api.ThreatMatch> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThreatMatch(o[0]);
   checkThreatMatch(o[1]);
 }
 
 core.int buildCounterFindThreatMatchesResponse = 0;
 buildFindThreatMatchesResponse() {
   var o = new api.FindThreatMatchesResponse();
   buildCounterFindThreatMatchesResponse++;
   if (buildCounterFindThreatMatchesResponse < 3) {
-    o.matches = buildUnnamed1086();
+    o.matches = buildUnnamed1089();
   }
   buildCounterFindThreatMatchesResponse--;
   return o;
 }
 
 checkFindThreatMatchesResponse(api.FindThreatMatchesResponse o) {
   buildCounterFindThreatMatchesResponse++;
   if (buildCounterFindThreatMatchesResponse < 3) {
-    checkUnnamed1086(o.matches);
+    checkUnnamed1089(o.matches);
   }
   buildCounterFindThreatMatchesResponse--;
 }
 
-buildUnnamed1087() {
+buildUnnamed1090() {
   var o = new core.List<api.ThreatListDescriptor>();
   o.add(buildThreatListDescriptor());
   o.add(buildThreatListDescriptor());
   return o;
 }
 
-checkUnnamed1087(core.List<api.ThreatListDescriptor> o) {
+checkUnnamed1090(core.List<api.ThreatListDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThreatListDescriptor(o[0]);
   checkThreatListDescriptor(o[1]);
 }
 
 core.int buildCounterListThreatListsResponse = 0;
 buildListThreatListsResponse() {
   var o = new api.ListThreatListsResponse();
   buildCounterListThreatListsResponse++;
   if (buildCounterListThreatListsResponse < 3) {
-    o.threatLists = buildUnnamed1087();
+    o.threatLists = buildUnnamed1090();
   }
   buildCounterListThreatListsResponse--;
   return o;
 }
 
 checkListThreatListsResponse(api.ListThreatListsResponse o) {
   buildCounterListThreatListsResponse++;
   if (buildCounterListThreatListsResponse < 3) {
-    checkUnnamed1087(o.threatLists);
+    checkUnnamed1090(o.threatLists);
   }
   buildCounterListThreatListsResponse--;
 }
 
 core.int buildCounterListUpdateRequest = 0;
 buildListUpdateRequest() {
   var o = new api.ListUpdateRequest();
   buildCounterListUpdateRequest++;
   if (buildCounterListUpdateRequest < 3) {
     o.constraints = buildConstraints();
@@ skipping 11 matching lines @@
   if (buildCounterListUpdateRequest < 3) {
     checkConstraints(o.constraints);
     unittest.expect(o.platformType, unittest.equals('foo'));
     unittest.expect(o.state, unittest.equals('foo'));
     unittest.expect(o.threatEntryType, unittest.equals('foo'));
     unittest.expect(o.threatType, unittest.equals('foo'));
   }
   buildCounterListUpdateRequest--;
 }
 
-buildUnnamed1088() {
+buildUnnamed1091() {
   var o = new core.List<api.ThreatEntrySet>();
   o.add(buildThreatEntrySet());
   o.add(buildThreatEntrySet());
   return o;
 }
 
-checkUnnamed1088(core.List<api.ThreatEntrySet> o) {
+checkUnnamed1091(core.List<api.ThreatEntrySet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThreatEntrySet(o[0]);
   checkThreatEntrySet(o[1]);
 }
 
-buildUnnamed1089() {
+buildUnnamed1092() {
   var o = new core.List<api.ThreatEntrySet>();
   o.add(buildThreatEntrySet());
   o.add(buildThreatEntrySet());
   return o;
 }
 
-checkUnnamed1089(core.List<api.ThreatEntrySet> o) {
+checkUnnamed1092(core.List<api.ThreatEntrySet> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThreatEntrySet(o[0]);
   checkThreatEntrySet(o[1]);
 }
 
 core.int buildCounterListUpdateResponse = 0;
 buildListUpdateResponse() {
   var o = new api.ListUpdateResponse();
   buildCounterListUpdateResponse++;
   if (buildCounterListUpdateResponse < 3) {
-    o.additions = buildUnnamed1088();
+    o.additions = buildUnnamed1091();
     o.checksum = buildChecksum();
     o.newClientState = "foo";
     o.platformType = "foo";
-    o.removals = buildUnnamed1089();
+    o.removals = buildUnnamed1092();
     o.responseType = "foo";
     o.threatEntryType = "foo";
     o.threatType = "foo";
   }
   buildCounterListUpdateResponse--;
   return o;
 }
 
 checkListUpdateResponse(api.ListUpdateResponse o) {
   buildCounterListUpdateResponse++;
   if (buildCounterListUpdateResponse < 3) {
-    checkUnnamed1088(o.additions);
+    checkUnnamed1091(o.additions);
     checkChecksum(o.checksum);
     unittest.expect(o.newClientState, unittest.equals('foo'));
     unittest.expect(o.platformType, unittest.equals('foo'));
-    checkUnnamed1089(o.removals);
+    checkUnnamed1092(o.removals);
     unittest.expect(o.responseType, unittest.equals('foo'));
     unittest.expect(o.threatEntryType, unittest.equals('foo'));
     unittest.expect(o.threatType, unittest.equals('foo'));
   }
   buildCounterListUpdateResponse--;
 }
 
 core.int buildCounterMetadataEntry = 0;
 buildMetadataEntry() {
   var o = new api.MetadataEntry();
@@ skipping 29 matching lines @@
 
 checkRawHashes(api.RawHashes o) {
   buildCounterRawHashes++;
   if (buildCounterRawHashes < 3) {
     unittest.expect(o.prefixSize, unittest.equals(42));
     unittest.expect(o.rawHashes, unittest.equals('foo'));
   }
   buildCounterRawHashes--;
 }
 
-buildUnnamed1090() {
+buildUnnamed1093() {
   var o = new core.List<core.int>();
   o.add(42);
   o.add(42);
   return o;
 }
 
-checkUnnamed1090(core.List<core.int> o) {
+checkUnnamed1093(core.List<core.int> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals(42));
   unittest.expect(o[1], unittest.equals(42));
 }
 
 core.int buildCounterRawIndices = 0;
 buildRawIndices() {
   var o = new api.RawIndices();
   buildCounterRawIndices++;
   if (buildCounterRawIndices < 3) {
-    o.indices = buildUnnamed1090();
+    o.indices = buildUnnamed1093();
   }
   buildCounterRawIndices--;
   return o;
 }
 
 checkRawIndices(api.RawIndices o) {
   buildCounterRawIndices++;
   if (buildCounterRawIndices < 3) {
-    checkUnnamed1090(o.indices);
+    checkUnnamed1093(o.indices);
   }
   buildCounterRawIndices--;
 }
 
 core.int buildCounterRiceDeltaEncoding = 0;
 buildRiceDeltaEncoding() {
   var o = new api.RiceDeltaEncoding();
   buildCounterRiceDeltaEncoding++;
   if (buildCounterRiceDeltaEncoding < 3) {
     o.encodedData = "foo";
@@ skipping 32 matching lines @@
 checkThreatEntry(api.ThreatEntry o) {
   buildCounterThreatEntry++;
   if (buildCounterThreatEntry < 3) {
     unittest.expect(o.digest, unittest.equals('foo'));
     unittest.expect(o.hash, unittest.equals('foo'));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterThreatEntry--;
 }
 
-buildUnnamed1091() {
+buildUnnamed1094() {
   var o = new core.List<api.MetadataEntry>();
   o.add(buildMetadataEntry());
   o.add(buildMetadataEntry());
   return o;
 }
 
-checkUnnamed1091(core.List<api.MetadataEntry> o) {
+checkUnnamed1094(core.List<api.MetadataEntry> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetadataEntry(o[0]);
   checkMetadataEntry(o[1]);
 }
 
 core.int buildCounterThreatEntryMetadata = 0;
 buildThreatEntryMetadata() {
   var o = new api.ThreatEntryMetadata();
   buildCounterThreatEntryMetadata++;
   if (buildCounterThreatEntryMetadata < 3) {
-    o.entries = buildUnnamed1091();
+    o.entries = buildUnnamed1094();
   }
   buildCounterThreatEntryMetadata--;
   return o;
 }
 
 checkThreatEntryMetadata(api.ThreatEntryMetadata o) {
   buildCounterThreatEntryMetadata++;
   if (buildCounterThreatEntryMetadata < 3) {
-    checkUnnamed1091(o.entries);
+    checkUnnamed1094(o.entries);
   }
   buildCounterThreatEntryMetadata--;
 }
 
 core.int buildCounterThreatEntrySet = 0;
 buildThreatEntrySet() {
   var o = new api.ThreatEntrySet();
   buildCounterThreatEntrySet++;
   if (buildCounterThreatEntrySet < 3) {
     o.compressionType = "foo";
@@ skipping 11 matching lines @@
   if (buildCounterThreatEntrySet < 3) {
     unittest.expect(o.compressionType, unittest.equals('foo'));
     checkRawHashes(o.rawHashes);
     checkRawIndices(o.rawIndices);
     checkRiceDeltaEncoding(o.riceHashes);
     checkRiceDeltaEncoding(o.riceIndices);
   }
   buildCounterThreatEntrySet--;
 }
 
-buildUnnamed1092() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1092(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'));
-}
-
-buildUnnamed1093() {
-  var o = new core.List<api.ThreatEntry>();
-  o.add(buildThreatEntry());
-  o.add(buildThreatEntry());
-  return o;
-}
-
-checkUnnamed1093(core.List<api.ThreatEntry> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkThreatEntry(o[0]);
-  checkThreatEntry(o[1]);
-}
-
-buildUnnamed1094() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1094(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'));
-}
-
 buildUnnamed1095() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed1095(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'));
+}
+
+buildUnnamed1096() {
+  var o = new core.List<api.ThreatEntry>();
+  o.add(buildThreatEntry());
+  o.add(buildThreatEntry());
+  return o;
+}
+
+checkUnnamed1096(core.List<api.ThreatEntry> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkThreatEntry(o[0]);
+  checkThreatEntry(o[1]);
+}
+
+buildUnnamed1097() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1097(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'));
+}
+
+buildUnnamed1098() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1098(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 buildCounterThreatInfo = 0;
 buildThreatInfo() {
   var o = new api.ThreatInfo();
   buildCounterThreatInfo++;
   if (buildCounterThreatInfo < 3) {
-    o.platformTypes = buildUnnamed1092();
-    o.threatEntries = buildUnnamed1093();
-    o.threatEntryTypes = buildUnnamed1094();
-    o.threatTypes = buildUnnamed1095();
+    o.platformTypes = buildUnnamed1095();
+    o.threatEntries = buildUnnamed1096();
+    o.threatEntryTypes = buildUnnamed1097();
+    o.threatTypes = buildUnnamed1098();
   }
   buildCounterThreatInfo--;
   return o;
 }
 
 checkThreatInfo(api.ThreatInfo o) {
   buildCounterThreatInfo++;
   if (buildCounterThreatInfo < 3) {
-    checkUnnamed1092(o.platformTypes);
-    checkUnnamed1093(o.threatEntries);
-    checkUnnamed1094(o.threatEntryTypes);
-    checkUnnamed1095(o.threatTypes);
+    checkUnnamed1095(o.platformTypes);
+    checkUnnamed1096(o.threatEntries);
+    checkUnnamed1097(o.threatEntryTypes);
+    checkUnnamed1098(o.threatTypes);
   }
   buildCounterThreatInfo--;
 }
 
 core.int buildCounterThreatListDescriptor = 0;
 buildThreatListDescriptor() {
   var o = new api.ThreatListDescriptor();
   buildCounterThreatListDescriptor++;
   if (buildCounterThreatListDescriptor < 3) {
     o.platformType = "foo";
@@ skipping 36 matching lines @@
     unittest.expect(o.cacheDuration, unittest.equals('foo'));
     unittest.expect(o.platformType, unittest.equals('foo'));
     checkThreatEntry(o.threat);
     checkThreatEntryMetadata(o.threatEntryMetadata);
     unittest.expect(o.threatEntryType, unittest.equals('foo'));
     unittest.expect(o.threatType, unittest.equals('foo'));
   }
   buildCounterThreatMatch--;
 }
 
-
 main() {
   unittest.group("obj-schema-Checksum", () {
     unittest.test("to-json--from-json", () {
       var o = buildChecksum();
       var od = new api.Checksum.fromJson(o.toJson());
       checkChecksum(od);
     });
   });
 
-
   unittest.group("obj-schema-ClientInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildClientInfo();
       var od = new api.ClientInfo.fromJson(o.toJson());
       checkClientInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-Constraints", () {
     unittest.test("to-json--from-json", () {
       var o = buildConstraints();
       var od = new api.Constraints.fromJson(o.toJson());
       checkConstraints(od);
     });
   });
 
-
   unittest.group("obj-schema-FetchThreatListUpdatesRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildFetchThreatListUpdatesRequest();
       var od = new api.FetchThreatListUpdatesRequest.fromJson(o.toJson());
       checkFetchThreatListUpdatesRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-FetchThreatListUpdatesResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildFetchThreatListUpdatesResponse();
       var od = new api.FetchThreatListUpdatesResponse.fromJson(o.toJson());
       checkFetchThreatListUpdatesResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-FindFullHashesRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildFindFullHashesRequest();
       var od = new api.FindFullHashesRequest.fromJson(o.toJson());
       checkFindFullHashesRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-FindFullHashesResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildFindFullHashesResponse();
       var od = new api.FindFullHashesResponse.fromJson(o.toJson());
       checkFindFullHashesResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-FindThreatMatchesRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildFindThreatMatchesRequest();
       var od = new api.FindThreatMatchesRequest.fromJson(o.toJson());
       checkFindThreatMatchesRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-FindThreatMatchesResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildFindThreatMatchesResponse();
       var od = new api.FindThreatMatchesResponse.fromJson(o.toJson());
       checkFindThreatMatchesResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ListThreatListsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListThreatListsResponse();
       var od = new api.ListThreatListsResponse.fromJson(o.toJson());
       checkListThreatListsResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ListUpdateRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildListUpdateRequest();
       var od = new api.ListUpdateRequest.fromJson(o.toJson());
       checkListUpdateRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-ListUpdateResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListUpdateResponse();
       var od = new api.ListUpdateResponse.fromJson(o.toJson());
       checkListUpdateResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-MetadataEntry", () {
     unittest.test("to-json--from-json", () {
       var o = buildMetadataEntry();
       var od = new api.MetadataEntry.fromJson(o.toJson());
       checkMetadataEntry(od);
     });
   });
 
-
   unittest.group("obj-schema-RawHashes", () {
     unittest.test("to-json--from-json", () {
       var o = buildRawHashes();
       var od = new api.RawHashes.fromJson(o.toJson());
       checkRawHashes(od);
     });
   });
 
-
   unittest.group("obj-schema-RawIndices", () {
     unittest.test("to-json--from-json", () {
       var o = buildRawIndices();
       var od = new api.RawIndices.fromJson(o.toJson());
       checkRawIndices(od);
     });
   });
 
-
   unittest.group("obj-schema-RiceDeltaEncoding", () {
     unittest.test("to-json--from-json", () {
       var o = buildRiceDeltaEncoding();
       var od = new api.RiceDeltaEncoding.fromJson(o.toJson());
       checkRiceDeltaEncoding(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatEntry", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatEntry();
       var od = new api.ThreatEntry.fromJson(o.toJson());
       checkThreatEntry(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatEntryMetadata", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatEntryMetadata();
       var od = new api.ThreatEntryMetadata.fromJson(o.toJson());
       checkThreatEntryMetadata(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatEntrySet", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatEntrySet();
       var od = new api.ThreatEntrySet.fromJson(o.toJson());
       checkThreatEntrySet(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatInfo();
       var od = new api.ThreatInfo.fromJson(o.toJson());
       checkThreatInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatListDescriptor", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatListDescriptor();
       var od = new api.ThreatListDescriptor.fromJson(o.toJson());
       checkThreatListDescriptor(od);
     });
   });
 
-
   unittest.group("obj-schema-ThreatMatch", () {
     unittest.test("to-json--from-json", () {
       var o = buildThreatMatch();
       var od = new api.ThreatMatch.fromJson(o.toJson());
       checkThreatMatch(od);
     });
   });
 
-
   unittest.group("resource-EncodedFullHashesResourceApi", () {
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
-      api.EncodedFullHashesResourceApi res = new api.SafebrowsingApi(mock).encodedFullHashes;
+      api.EncodedFullHashesResourceApi res =
+          new api.SafebrowsingApi(mock).encodedFullHashes;
       var arg_encodedRequest = "foo";
+      var arg_clientVersion = "foo";
       var arg_clientId = "foo";
-      var arg_clientVersion = "foo";
       mock.register(unittest.expectAsync2((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("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("v4/encodedFullHashes/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21),
+            unittest.equals("v4/encodedFullHashes/"));
         pathOffset += 21;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_encodedRequest"));
 
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["clientId"].first, unittest.equals(arg_clientId));
-        unittest.expect(queryMap["clientVersion"].first, unittest.equals(arg_clientVersion));
-
+        unittest.expect(queryMap["clientVersion"].first,
+            unittest.equals(arg_clientVersion));
+        unittest.expect(
+            queryMap["clientId"].first, unittest.equals(arg_clientId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFindFullHashesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.get(arg_encodedRequest, clientId: arg_clientId, clientVersion: arg_clientVersion).then(unittest.expectAsync1(((api.FindFullHashesResponse response) {
+      res
+          .get(arg_encodedRequest,
+              clientVersion: arg_clientVersion, clientId: arg_clientId)
+          .then(unittest.expectAsync1(((api.FindFullHashesResponse response) {
         checkFindFullHashesResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-EncodedUpdatesResourceApi", () {
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
-      api.EncodedUpdatesResourceApi res = new api.SafebrowsingApi(mock).encodedUpdates;
+      api.EncodedUpdatesResourceApi res =
+          new api.SafebrowsingApi(mock).encodedUpdates;
       var arg_encodedRequest = "foo";
       var arg_clientId = "foo";
       var arg_clientVersion = "foo";
       mock.register(unittest.expectAsync2((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("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("v4/encodedUpdates/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18),
+            unittest.equals("v4/encodedUpdates/"));
         pathOffset += 18;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_encodedRequest"));
 
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["clientId"].first, unittest.equals(arg_clientId));
-        unittest.expect(queryMap["clientVersion"].first, unittest.equals(arg_clientVersion));
-
+        unittest.expect(
+            queryMap["clientId"].first, unittest.equals(arg_clientId));
+        unittest.expect(queryMap["clientVersion"].first,
+            unittest.equals(arg_clientVersion));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFetchThreatListUpdatesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.get(arg_encodedRequest, clientId: arg_clientId, clientVersion: arg_clientVersion).then(unittest.expectAsync1(((api.FetchThreatListUpdatesResponse response) {
+      res
+          .get(arg_encodedRequest,
+              clientId: arg_clientId, clientVersion: arg_clientVersion)
+          .then(unittest
+              .expectAsync1(((api.FetchThreatListUpdatesResponse response) {
         checkFetchThreatListUpdatesResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-FullHashesResourceApi", () {
     unittest.test("method--find", () {
-
       var mock = new HttpServerMock();
       api.FullHashesResourceApi res = new api.SafebrowsingApi(mock).fullHashes;
       var arg_request = buildFindFullHashesRequest();
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.FindFullHashesRequest.fromJson(json);
         checkFindFullHashesRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
-        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("v4/fullHashes:find"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18),
+            unittest.equals("v4/fullHashes:find"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFindFullHashesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.find(arg_request).then(unittest.expectAsync1(((api.FindFullHashesResponse response) {
+      res
+          .find(arg_request)
+          .then(unittest.expectAsync1(((api.FindFullHashesResponse response) {
         checkFindFullHashesResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ThreatListUpdatesResourceApi", () {
     unittest.test("method--fetch", () {
-
       var mock = new HttpServerMock();
-      api.ThreatListUpdatesResourceApi res = new api.SafebrowsingApi(mock).threatListUpdates;
+      api.ThreatListUpdatesResourceApi res =
+          new api.SafebrowsingApi(mock).threatListUpdates;
       var arg_request = buildFetchThreatListUpdatesRequest();
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.FetchThreatListUpdatesRequest.fromJson(json);
         checkFetchThreatListUpdatesRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
-        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.equals("v4/threatListUpdates:fetch"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 26),
+            unittest.equals("v4/threatListUpdates:fetch"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFetchThreatListUpdatesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.fetch(arg_request).then(unittest.expectAsync1(((api.FetchThreatListUpdatesResponse response) {
+      res.fetch(arg_request).then(
+          unittest.expectAsync1(((api.FetchThreatListUpdatesResponse response) {
         checkFetchThreatListUpdatesResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ThreatListsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.ThreatListsResourceApi res = new api.SafebrowsingApi(mock).threatLists;
+      api.ThreatListsResourceApi res =
+          new api.SafebrowsingApi(mock).threatLists;
       mock.register(unittest.expectAsync2((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("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("v4/threatLists"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("v4/threatLists"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListThreatListsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list().then(unittest.expectAsync1(((api.ListThreatListsResponse response) {
+      res
+          .list()
+          .then(unittest.expectAsync1(((api.ListThreatListsResponse response) {
         checkListThreatListsResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ThreatMatchesResourceApi", () {
     unittest.test("method--find", () {
-
       var mock = new HttpServerMock();
-      api.ThreatMatchesResourceApi res = new api.SafebrowsingApi(mock).threatMatches;
+      api.ThreatMatchesResourceApi res =
+          new api.SafebrowsingApi(mock).threatMatches;
       var arg_request = buildFindThreatMatchesRequest();
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.FindThreatMatchesRequest.fromJson(json);
         checkFindThreatMatchesRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
-        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
         pathOffset += 1;
-        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("v4/threatMatches:find"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21),
+            unittest.equals("v4/threatMatches:find"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFindThreatMatchesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.find(arg_request).then(unittest.expectAsync1(((api.FindThreatMatchesResponse response) {
+      res.find(arg_request).then(
+          unittest.expectAsync1(((api.FindThreatMatchesResponse response) {
         checkFindThreatMatchesResponse(response);
       })));
     });
-
   });
-
-
 }
-